You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

965 lines
26 KiB

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