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 /* 33 Package proto converts data structures to and from the wire format of 34 protocol buffers. It works in concert with the Go source code generated 35 for .proto files by the protocol compiler. 36 37 A summary of the properties of the protocol buffer interface 38 for a protocol buffer variable v: 39 40 - Names are turned from camel_case to CamelCase for export. 41 - There are no methods on v to set fields; just treat 42 them as structure fields. 43 - There are getters that return a field's value if set, 44 and return the field's default value if unset. 45 The getters work even if the receiver is a nil message. 46 - The zero value for a struct is its correct initialization state. 47 All desired fields must be set before marshaling. 48 - A Reset() method will restore a protobuf struct to its zero state. 49 - Non-repeated fields are pointers to the values; nil means unset. 50 That is, optional or required field int32 f becomes F *int32. 51 - Repeated fields are slices. 52 - Helper functions are available to aid the setting of fields. 53 msg.Foo = proto.String("hello") // set field 54 - Constants are defined to hold the default values of all fields that 55 have them. They have the form Default_StructName_FieldName. 56 Because the getter methods handle defaulted values, 57 direct use of these constants should be rare. 58 - Enums are given type names and maps from names to values. 59 Enum values are prefixed by the enclosing message's name, or by the 60 enum's type name if it is a top-level enum. Enum types have a String 61 method, and a Enum method to assist in message construction. 62 - Nested messages, groups and enums have type names prefixed with the name of 63 the surrounding message type. 64 - Extensions are given descriptor names that start with E_, 65 followed by an underscore-delimited list of the nested messages 66 that contain it (if any) followed by the CamelCased name of the 67 extension field itself. HasExtension, ClearExtension, GetExtension 68 and SetExtension are functions for manipulating extensions. 69 - Oneof field sets are given a single field in their message, 70 with distinguished wrapper types for each possible field value. 71 - Marshal and Unmarshal are functions to encode and decode the wire format. 72 73 When the .proto file specifies `syntax="proto3"`, there are some differences: 74 75 - Non-repeated fields of non-message type are values instead of pointers. 76 - Enum types do not get an Enum method. 77 78 The simplest way to describe this is to see an example. 79 Given file test.proto, containing 80 81 package example; 82 83 enum FOO { X = 17; } 84 85 message Test { 86 required string label = 1; 87 optional int32 type = 2 [default=77]; 88 repeated int64 reps = 3; 89 optional group OptionalGroup = 4 { 90 required string RequiredField = 5; 91 } 92 oneof union { 93 int32 number = 6; 94 string name = 7; 95 } 96 } 97 98 The resulting file, test.pb.go, is: 99 100 package example 101 102 import proto "github.com/gogo/protobuf/proto" 103 import math "math" 104 105 type FOO int32 106 const ( 107 FOO_X FOO = 17 108 ) 109 var FOO_name = map[int32]string{ 110 17: "X", 111 } 112 var FOO_value = map[string]int32{ 113 "X": 17, 114 } 115 116 func (x FOO) Enum() *FOO { 117 p := new(FOO) 118 *p = x 119 return p 120 } 121 func (x FOO) String() string { 122 return proto.EnumName(FOO_name, int32(x)) 123 } 124 func (x *FOO) UnmarshalJSON(data []byte) error { 125 value, err := proto.UnmarshalJSONEnum(FOO_value, data) 126 if err != nil { 127 return err 128 } 129 *x = FOO(value) 130 return nil 131 } 132 133 type Test struct { 134 Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` 135 Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` 136 Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` 137 Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` 138 // Types that are valid to be assigned to Union: 139 // *Test_Number 140 // *Test_Name 141 Union isTest_Union `protobuf_oneof:"union"` 142 XXX_unrecognized []byte `json:"-"` 143 } 144 func (m *Test) Reset() { *m = Test{} } 145 func (m *Test) String() string { return proto.CompactTextString(m) } 146 func (*Test) ProtoMessage() {} 147 148 type isTest_Union interface { 149 isTest_Union() 150 } 151 152 type Test_Number struct { 153 Number int32 `protobuf:"varint,6,opt,name=number"` 154 } 155 type Test_Name struct { 156 Name string `protobuf:"bytes,7,opt,name=name"` 157 } 158 159 func (*Test_Number) isTest_Union() {} 160 func (*Test_Name) isTest_Union() {} 161 162 func (m *Test) GetUnion() isTest_Union { 163 if m != nil { 164 return m.Union 165 } 166 return nil 167 } 168 const Default_Test_Type int32 = 77 169 170 func (m *Test) GetLabel() string { 171 if m != nil && m.Label != nil { 172 return *m.Label 173 } 174 return "" 175 } 176 177 func (m *Test) GetType() int32 { 178 if m != nil && m.Type != nil { 179 return *m.Type 180 } 181 return Default_Test_Type 182 } 183 184 func (m *Test) GetOptionalgroup() *Test_OptionalGroup { 185 if m != nil { 186 return m.Optionalgroup 187 } 188 return nil 189 } 190 191 type Test_OptionalGroup struct { 192 RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` 193 } 194 func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } 195 func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } 196 197 func (m *Test_OptionalGroup) GetRequiredField() string { 198 if m != nil && m.RequiredField != nil { 199 return *m.RequiredField 200 } 201 return "" 202 } 203 204 func (m *Test) GetNumber() int32 { 205 if x, ok := m.GetUnion().(*Test_Number); ok { 206 return x.Number 207 } 208 return 0 209 } 210 211 func (m *Test) GetName() string { 212 if x, ok := m.GetUnion().(*Test_Name); ok { 213 return x.Name 214 } 215 return "" 216 } 217 218 func init() { 219 proto.RegisterEnum("example.FOO", FOO_name, FOO_value) 220 } 221 222 To create and play with a Test object: 223 224 package main 225 226 import ( 227 "log" 228 229 "github.com/gogo/protobuf/proto" 230 pb "./example.pb" 231 ) 232 233 func main() { 234 test := &pb.Test{ 235 Label: proto.String("hello"), 236 Type: proto.Int32(17), 237 Reps: []int64{1, 2, 3}, 238 Optionalgroup: &pb.Test_OptionalGroup{ 239 RequiredField: proto.String("good bye"), 240 }, 241 Union: &pb.Test_Name{"fred"}, 242 } 243 data, err := proto.Marshal(test) 244 if err != nil { 245 log.Fatal("marshaling error: ", err) 246 } 247 newTest := &pb.Test{} 248 err = proto.Unmarshal(data, newTest) 249 if err != nil { 250 log.Fatal("unmarshaling error: ", err) 251 } 252 // Now test and newTest contain the same data. 253 if test.GetLabel() != newTest.GetLabel() { 254 log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) 255 } 256 // Use a type switch to determine which oneof was set. 257 switch u := test.Union.(type) { 258 case *pb.Test_Number: // u.Number contains the number. 259 case *pb.Test_Name: // u.Name contains the string. 260 } 261 // etc. 262 } 263 */ 264 package proto 265 266 import ( 267 "encoding/json" 268 "fmt" 269 "log" 270 "reflect" 271 "sort" 272 "strconv" 273 "sync" 274 ) 275 276 // RequiredNotSetError is an error type returned by either Marshal or Unmarshal. 277 // Marshal reports this when a required field is not initialized. 278 // Unmarshal reports this when a required field is missing from the wire data. 279 type RequiredNotSetError struct{ field string } 280 281 func (e *RequiredNotSetError) Error() string { 282 if e.field == "" { 283 return fmt.Sprintf("proto: required field not set") 284 } 285 return fmt.Sprintf("proto: required field %q not set", e.field) 286 } 287 func (e *RequiredNotSetError) RequiredNotSet() bool { 288 return true 289 } 290 291 type invalidUTF8Error struct{ field string } 292 293 func (e *invalidUTF8Error) Error() string { 294 if e.field == "" { 295 return "proto: invalid UTF-8 detected" 296 } 297 return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field) 298 } 299 func (e *invalidUTF8Error) InvalidUTF8() bool { 300 return true 301 } 302 303 // errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8. 304 // This error should not be exposed to the external API as such errors should 305 // be recreated with the field information. 306 var errInvalidUTF8 = &invalidUTF8Error{} 307 308 // isNonFatal reports whether the error is either a RequiredNotSet error 309 // or a InvalidUTF8 error. 310 func isNonFatal(err error) bool { 311 if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() { 312 return true 313 } 314 if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() { 315 return true 316 } 317 return false 318 } 319 320 type nonFatal struct{ E error } 321 322 // Merge merges err into nf and reports whether it was successful. 323 // Otherwise it returns false for any fatal non-nil errors. 324 func (nf *nonFatal) Merge(err error) (ok bool) { 325 if err == nil { 326 return true // not an error 327 } 328 if !isNonFatal(err) { 329 return false // fatal error 330 } 331 if nf.E == nil { 332 nf.E = err // store first instance of non-fatal error 333 } 334 return true 335 } 336 337 // Message is implemented by generated protocol buffer messages. 338 type Message interface { 339 Reset() 340 String() string 341 ProtoMessage() 342 } 343 344 // A Buffer is a buffer manager for marshaling and unmarshaling 345 // protocol buffers. It may be reused between invocations to 346 // reduce memory usage. It is not necessary to use a Buffer; 347 // the global functions Marshal and Unmarshal create a 348 // temporary Buffer and are fine for most applications. 349 type Buffer struct { 350 buf []byte // encode/decode byte stream 351 index int // read point 352 353 deterministic bool 354 } 355 356 // NewBuffer allocates a new Buffer and initializes its internal data to 357 // the contents of the argument slice. 358 func NewBuffer(e []byte) *Buffer { 359 return &Buffer{buf: e} 360 } 361 362 // Reset resets the Buffer, ready for marshaling a new protocol buffer. 363 func (p *Buffer) Reset() { 364 p.buf = p.buf[0:0] // for reading/writing 365 p.index = 0 // for reading 366 } 367 368 // SetBuf replaces the internal buffer with the slice, 369 // ready for unmarshaling the contents of the slice. 370 func (p *Buffer) SetBuf(s []byte) { 371 p.buf = s 372 p.index = 0 373 } 374 375 // Bytes returns the contents of the Buffer. 376 func (p *Buffer) Bytes() []byte { return p.buf } 377 378 // SetDeterministic sets whether to use deterministic serialization. 379 // 380 // Deterministic serialization guarantees that for a given binary, equal 381 // messages will always be serialized to the same bytes. This implies: 382 // 383 // - Repeated serialization of a message will return the same bytes. 384 // - Different processes of the same binary (which may be executing on 385 // different machines) will serialize equal messages to the same bytes. 386 // 387 // Note that the deterministic serialization is NOT canonical across 388 // languages. It is not guaranteed to remain stable over time. It is unstable 389 // across different builds with schema changes due to unknown fields. 390 // Users who need canonical serialization (e.g., persistent storage in a 391 // canonical form, fingerprinting, etc.) should define their own 392 // canonicalization specification and implement their own serializer rather 393 // than relying on this API. 394 // 395 // If deterministic serialization is requested, map entries will be sorted 396 // by keys in lexographical order. This is an implementation detail and 397 // subject to change. 398 func (p *Buffer) SetDeterministic(deterministic bool) { 399 p.deterministic = deterministic 400 } 401 402 /* 403 * Helper routines for simplifying the creation of optional fields of basic type. 404 */ 405 406 // Bool is a helper routine that allocates a new bool value 407 // to store v and returns a pointer to it. 408 func Bool(v bool) *bool { 409 return &v 410 } 411 412 // Int32 is a helper routine that allocates a new int32 value 413 // to store v and returns a pointer to it. 414 func Int32(v int32) *int32 { 415 return &v 416 } 417 418 // Int is a helper routine that allocates a new int32 value 419 // to store v and returns a pointer to it, but unlike Int32 420 // its argument value is an int. 421 func Int(v int) *int32 { 422 p := new(int32) 423 *p = int32(v) 424 return p 425 } 426 427 // Int64 is a helper routine that allocates a new int64 value 428 // to store v and returns a pointer to it. 429 func Int64(v int64) *int64 { 430 return &v 431 } 432 433 // Float32 is a helper routine that allocates a new float32 value 434 // to store v and returns a pointer to it. 435 func Float32(v float32) *float32 { 436 return &v 437 } 438 439 // Float64 is a helper routine that allocates a new float64 value 440 // to store v and returns a pointer to it. 441 func Float64(v float64) *float64 { 442 return &v 443 } 444 445 // Uint32 is a helper routine that allocates a new uint32 value 446 // to store v and returns a pointer to it. 447 func Uint32(v uint32) *uint32 { 448 return &v 449 } 450 451 // Uint64 is a helper routine that allocates a new uint64 value 452 // to store v and returns a pointer to it. 453 func Uint64(v uint64) *uint64 { 454 return &v 455 } 456 457 // String is a helper routine that allocates a new string value 458 // to store v and returns a pointer to it. 459 func String(v string) *string { 460 return &v 461 } 462 463 // EnumName is a helper function to simplify printing protocol buffer enums 464 // by name. Given an enum map and a value, it returns a useful string. 465 func EnumName(m map[int32]string, v int32) string { 466 s, ok := m[v] 467 if ok { 468 return s 469 } 470 return strconv.Itoa(int(v)) 471 } 472 473 // UnmarshalJSONEnum is a helper function to simplify recovering enum int values 474 // from their JSON-encoded representation. Given a map from the enum's symbolic 475 // names to its int values, and a byte buffer containing the JSON-encoded 476 // value, it returns an int32 that can be cast to the enum type by the caller. 477 // 478 // The function can deal with both JSON representations, numeric and symbolic. 479 func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { 480 if data[0] == '"' { 481 // New style: enums are strings. 482 var repr string 483 if err := json.Unmarshal(data, &repr); err != nil { 484 return -1, err 485 } 486 val, ok := m[repr] 487 if !ok { 488 return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) 489 } 490 return val, nil 491 } 492 // Old style: enums are ints. 493 var val int32 494 if err := json.Unmarshal(data, &val); err != nil { 495 return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) 496 } 497 return val, nil 498 } 499 500 // DebugPrint dumps the encoded data in b in a debugging format with a header 501 // including the string s. Used in testing but made available for general debugging. 502 func (p *Buffer) DebugPrint(s string, b []byte) { 503 var u uint64 504 505 obuf := p.buf 506 sindex := p.index 507 p.buf = b 508 p.index = 0 509 depth := 0 510 511 fmt.Printf("\n--- %s ---\n", s) 512 513 out: 514 for { 515 for i := 0; i < depth; i++ { 516 fmt.Print(" ") 517 } 518 519 index := p.index 520 if index == len(p.buf) { 521 break 522 } 523 524 op, err := p.DecodeVarint() 525 if err != nil { 526 fmt.Printf("%3d: fetching op err %v\n", index, err) 527 break out 528 } 529 tag := op >> 3 530 wire := op & 7 531 532 switch wire { 533 default: 534 fmt.Printf("%3d: t=%3d unknown wire=%d\n", 535 index, tag, wire) 536 break out 537 538 case WireBytes: 539 var r []byte 540 541 r, err = p.DecodeRawBytes(false) 542 if err != nil { 543 break out 544 } 545 fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) 546 if len(r) <= 6 { 547 for i := 0; i < len(r); i++ { 548 fmt.Printf(" %.2x", r[i]) 549 } 550 } else { 551 for i := 0; i < 3; i++ { 552 fmt.Printf(" %.2x", r[i]) 553 } 554 fmt.Printf(" ..") 555 for i := len(r) - 3; i < len(r); i++ { 556 fmt.Printf(" %.2x", r[i]) 557 } 558 } 559 fmt.Printf("\n") 560 561 case WireFixed32: 562 u, err = p.DecodeFixed32() 563 if err != nil { 564 fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) 565 break out 566 } 567 fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) 568 569 case WireFixed64: 570 u, err = p.DecodeFixed64() 571 if err != nil { 572 fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) 573 break out 574 } 575 fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) 576 577 case WireVarint: 578 u, err = p.DecodeVarint() 579 if err != nil { 580 fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) 581 break out 582 } 583 fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) 584 585 case WireStartGroup: 586 fmt.Printf("%3d: t=%3d start\n", index, tag) 587 depth++ 588 589 case WireEndGroup: 590 depth-- 591 fmt.Printf("%3d: t=%3d end\n", index, tag) 592 } 593 } 594 595 if depth != 0 { 596 fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) 597 } 598 fmt.Printf("\n") 599 600 p.buf = obuf 601 p.index = sindex 602 } 603 604 // SetDefaults sets unset protocol buffer fields to their default values. 605 // It only modifies fields that are both unset and have defined defaults. 606 // It recursively sets default values in any non-nil sub-messages. 607 func SetDefaults(pb Message) { 608 setDefaults(reflect.ValueOf(pb), true, false) 609 } 610 611 // v is a struct. 612 func setDefaults(v reflect.Value, recur, zeros bool) { 613 if v.Kind() == reflect.Ptr { 614 v = v.Elem() 615 } 616 617 defaultMu.RLock() 618 dm, ok := defaults[v.Type()] 619 defaultMu.RUnlock() 620 if !ok { 621 dm = buildDefaultMessage(v.Type()) 622 defaultMu.Lock() 623 defaults[v.Type()] = dm 624 defaultMu.Unlock() 625 } 626 627 for _, sf := range dm.scalars { 628 f := v.Field(sf.index) 629 if !f.IsNil() { 630 // field already set 631 continue 632 } 633 dv := sf.value 634 if dv == nil && !zeros { 635 // no explicit default, and don't want to set zeros 636 continue 637 } 638 fptr := f.Addr().Interface() // **T 639 // TODO: Consider batching the allocations we do here. 640 switch sf.kind { 641 case reflect.Bool: 642 b := new(bool) 643 if dv != nil { 644 *b = dv.(bool) 645 } 646 *(fptr.(**bool)) = b 647 case reflect.Float32: 648 f := new(float32) 649 if dv != nil { 650 *f = dv.(float32) 651 } 652 *(fptr.(**float32)) = f 653 case reflect.Float64: 654 f := new(float64) 655 if dv != nil { 656 *f = dv.(float64) 657 } 658 *(fptr.(**float64)) = f 659 case reflect.Int32: 660 // might be an enum 661 if ft := f.Type(); ft != int32PtrType { 662 // enum 663 f.Set(reflect.New(ft.Elem())) 664 if dv != nil { 665 f.Elem().SetInt(int64(dv.(int32))) 666 } 667 } else { 668 // int32 field 669 i := new(int32) 670 if dv != nil { 671 *i = dv.(int32) 672 } 673 *(fptr.(**int32)) = i 674 } 675 case reflect.Int64: 676 i := new(int64) 677 if dv != nil { 678 *i = dv.(int64) 679 } 680 *(fptr.(**int64)) = i 681 case reflect.String: 682 s := new(string) 683 if dv != nil { 684 *s = dv.(string) 685 } 686 *(fptr.(**string)) = s 687 case reflect.Uint8: 688 // exceptional case: []byte 689 var b []byte 690 if dv != nil { 691 db := dv.([]byte) 692 b = make([]byte, len(db)) 693 copy(b, db) 694 } else { 695 b = []byte{} 696 } 697 *(fptr.(*[]byte)) = b 698 case reflect.Uint32: 699 u := new(uint32) 700 if dv != nil { 701 *u = dv.(uint32) 702 } 703 *(fptr.(**uint32)) = u 704 case reflect.Uint64: 705 u := new(uint64) 706 if dv != nil { 707 *u = dv.(uint64) 708 } 709 *(fptr.(**uint64)) = u 710 default: 711 log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) 712 } 713 } 714 715 for _, ni := range dm.nested { 716 f := v.Field(ni) 717 // f is *T or T or []*T or []T 718 switch f.Kind() { 719 case reflect.Struct: 720 setDefaults(f, recur, zeros) 721 722 case reflect.Ptr: 723 if f.IsNil() { 724 continue 725 } 726 setDefaults(f, recur, zeros) 727 728 case reflect.Slice: 729 for i := 0; i < f.Len(); i++ { 730 e := f.Index(i) 731 if e.Kind() == reflect.Ptr && e.IsNil() { 732 continue 733 } 734 setDefaults(e, recur, zeros) 735 } 736 737 case reflect.Map: 738 for _, k := range f.MapKeys() { 739 e := f.MapIndex(k) 740 if e.IsNil() { 741 continue 742 } 743 setDefaults(e, recur, zeros) 744 } 745 } 746 } 747 } 748 749 var ( 750 // defaults maps a protocol buffer struct type to a slice of the fields, 751 // with its scalar fields set to their proto-declared non-zero default values. 752 defaultMu sync.RWMutex 753 defaults = make(map[reflect.Type]defaultMessage) 754 755 int32PtrType = reflect.TypeOf((*int32)(nil)) 756 ) 757 758 // defaultMessage represents information about the default values of a message. 759 type defaultMessage struct { 760 scalars []scalarField 761 nested []int // struct field index of nested messages 762 } 763 764 type scalarField struct { 765 index int // struct field index 766 kind reflect.Kind // element type (the T in *T or []T) 767 value interface{} // the proto-declared default value, or nil 768 } 769 770 // t is a struct type. 771 func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { 772 sprop := GetProperties(t) 773 for _, prop := range sprop.Prop { 774 fi, ok := sprop.decoderTags.get(prop.Tag) 775 if !ok { 776 // XXX_unrecognized 777 continue 778 } 779 ft := t.Field(fi).Type 780 781 sf, nested, err := fieldDefault(ft, prop) 782 switch { 783 case err != nil: 784 log.Print(err) 785 case nested: 786 dm.nested = append(dm.nested, fi) 787 case sf != nil: 788 sf.index = fi 789 dm.scalars = append(dm.scalars, *sf) 790 } 791 } 792 793 return dm 794 } 795 796 // fieldDefault returns the scalarField for field type ft. 797 // sf will be nil if the field can not have a default. 798 // nestedMessage will be true if this is a nested message. 799 // Note that sf.index is not set on return. 800 func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { 801 var canHaveDefault bool 802 switch ft.Kind() { 803 case reflect.Struct: 804 nestedMessage = true // non-nullable 805 806 case reflect.Ptr: 807 if ft.Elem().Kind() == reflect.Struct { 808 nestedMessage = true 809 } else { 810 canHaveDefault = true // proto2 scalar field 811 } 812 813 case reflect.Slice: 814 switch ft.Elem().Kind() { 815 case reflect.Ptr, reflect.Struct: 816 nestedMessage = true // repeated message 817 case reflect.Uint8: 818 canHaveDefault = true // bytes field 819 } 820 821 case reflect.Map: 822 if ft.Elem().Kind() == reflect.Ptr { 823 nestedMessage = true // map with message values 824 } 825 } 826 827 if !canHaveDefault { 828 if nestedMessage { 829 return nil, true, nil 830 } 831 return nil, false, nil 832 } 833 834 // We now know that ft is a pointer or slice. 835 sf = &scalarField{kind: ft.Elem().Kind()} 836 837 // scalar fields without defaults 838 if !prop.HasDefault { 839 return sf, false, nil 840 } 841 842 // a scalar field: either *T or []byte 843 switch ft.Elem().Kind() { 844 case reflect.Bool: 845 x, err := strconv.ParseBool(prop.Default) 846 if err != nil { 847 return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) 848 } 849 sf.value = x 850 case reflect.Float32: 851 x, err := strconv.ParseFloat(prop.Default, 32) 852 if err != nil { 853 return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) 854 } 855 sf.value = float32(x) 856 case reflect.Float64: 857 x, err := strconv.ParseFloat(prop.Default, 64) 858 if err != nil { 859 return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) 860 } 861 sf.value = x 862 case reflect.Int32: 863 x, err := strconv.ParseInt(prop.Default, 10, 32) 864 if err != nil { 865 return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) 866 } 867 sf.value = int32(x) 868 case reflect.Int64: 869 x, err := strconv.ParseInt(prop.Default, 10, 64) 870 if err != nil { 871 return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) 872 } 873 sf.value = x 874 case reflect.String: 875 sf.value = prop.Default 876 case reflect.Uint8: 877 // []byte (not *uint8) 878 sf.value = []byte(prop.Default) 879 case reflect.Uint32: 880 x, err := strconv.ParseUint(prop.Default, 10, 32) 881 if err != nil { 882 return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) 883 } 884 sf.value = uint32(x) 885 case reflect.Uint64: 886 x, err := strconv.ParseUint(prop.Default, 10, 64) 887 if err != nil { 888 return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) 889 } 890 sf.value = x 891 default: 892 return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) 893 } 894 895 return sf, false, nil 896 } 897 898 // mapKeys returns a sort.Interface to be used for sorting the map keys. 899 // Map fields may have key types of non-float scalars, strings and enums. 900 func mapKeys(vs []reflect.Value) sort.Interface { 901 s := mapKeySorter{vs: vs} 902 903 // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps. 904 if len(vs) == 0 { 905 return s 906 } 907 switch vs[0].Kind() { 908 case reflect.Int32, reflect.Int64: 909 s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } 910 case reflect.Uint32, reflect.Uint64: 911 s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } 912 case reflect.Bool: 913 s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true 914 case reflect.String: 915 s.less = func(a, b reflect.Value) bool { return a.String() < b.String() } 916 default: 917 panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind())) 918 } 919 920 return s 921 } 922 923 type mapKeySorter struct { 924 vs []reflect.Value 925 less func(a, b reflect.Value) bool 926 } 927 928 func (s mapKeySorter) Len() int { return len(s.vs) } 929 func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } 930 func (s mapKeySorter) Less(i, j int) bool { 931 return s.less(s.vs[i], s.vs[j]) 932 } 933 934 // isProto3Zero reports whether v is a zero proto3 value. 935 func isProto3Zero(v reflect.Value) bool { 936 switch v.Kind() { 937 case reflect.Bool: 938 return !v.Bool() 939 case reflect.Int32, reflect.Int64: 940 return v.Int() == 0 941 case reflect.Uint32, reflect.Uint64: 942 return v.Uint() == 0 943 case reflect.Float32, reflect.Float64: 944 return v.Float() == 0 945 case reflect.String: 946 return v.String() == "" 947 } 948 return false 949 } 950 951 const ( 952 // ProtoPackageIsVersion3 is referenced from generated protocol buffer files 953 // to assert that that code is compatible with this version of the proto package. 954 GoGoProtoPackageIsVersion3 = true 955 956 // ProtoPackageIsVersion2 is referenced from generated protocol buffer files 957 // to assert that that code is compatible with this version of the proto package. 958 GoGoProtoPackageIsVersion2 = true 959 960 // ProtoPackageIsVersion1 is referenced from generated protocol buffer files 961 // to assert that that code is compatible with this version of the proto package. 962 GoGoProtoPackageIsVersion1 = true 963 ) 964 965 // InternalMessageInfo is a type used internally by generated .pb.go files. 966 // This type is not intended to be used by non-generated code. 967 // This type is not subject to any compatibility guarantee. 968 type InternalMessageInfo struct { 969 marshal *marshalInfo 970 unmarshal *unmarshalInfo 971 merge *mergeInfo 972 discard *discardInfo 973 } 974