| 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 |
} |