vendor/github.com/golang/protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: test_objects.proto
   3
   4 package jsonpb
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import google_protobuf "github.com/golang/protobuf/ptypes/any"
  10 import google_protobuf1 "github.com/golang/protobuf/ptypes/duration"
  11 import google_protobuf2 "github.com/golang/protobuf/ptypes/struct"
  12 import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp"
  13 import google_protobuf4 "github.com/golang/protobuf/ptypes/wrappers"
  14
  15 // Reference imports to suppress errors if they are not otherwise used.
  16 var _ = proto.Marshal
  17 var _ = fmt.Errorf
  18 var _ = math.Inf
  19
  20 type Widget_Color int32
  21
  22 const (
  23         Widget_RED   Widget_Color = 0
  24         Widget_GREEN Widget_Color = 1
  25         Widget_BLUE  Widget_Color = 2
  26 )
  27
  28 var Widget_Color_name = map[int32]string{
  29         0: "RED",
  30         1: "GREEN",
  31         2: "BLUE",
  32 }
  33 var Widget_Color_value = map[string]int32{
  34         "RED":   0,
  35         "GREEN": 1,
  36         "BLUE":  2,
  37 }
  38
  39 func (x Widget_Color) Enum() *Widget_Color {
  40         p := new(Widget_Color)
  41         *p = x
  42         return p
  43 }
  44 func (x Widget_Color) String() string {
  45         return proto.EnumName(Widget_Color_name, int32(x))
  46 }
  47 func (x *Widget_Color) UnmarshalJSON(data []byte) error {
  48         value, err := proto.UnmarshalJSONEnum(Widget_Color_value, data, "Widget_Color")
  49         if err != nil {
  50                 return err
  51         }
  52         *x = Widget_Color(value)
  53         return nil
  54 }
  55 func (Widget_Color) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{3, 0} }
  56
  57 // Test message for holding primitive types.
  58 type Simple struct {
  59         OBool            *bool    `protobuf:"varint,1,opt,name=o_bool,json=oBool" json:"o_bool,omitempty"`
  60         OInt32           *int32   `protobuf:"varint,2,opt,name=o_int32,json=oInt32" json:"o_int32,omitempty"`
  61         OInt64           *int64   `protobuf:"varint,3,opt,name=o_int64,json=oInt64" json:"o_int64,omitempty"`
  62         OUint32          *uint32  `protobuf:"varint,4,opt,name=o_uint32,json=oUint32" json:"o_uint32,omitempty"`
  63         OUint64          *uint64  `protobuf:"varint,5,opt,name=o_uint64,json=oUint64" json:"o_uint64,omitempty"`
  64         OSint32          *int32   `protobuf:"zigzag32,6,opt,name=o_sint32,json=oSint32" json:"o_sint32,omitempty"`
  65         OSint64          *int64   `protobuf:"zigzag64,7,opt,name=o_sint64,json=oSint64" json:"o_sint64,omitempty"`
  66         OFloat           *float32 `protobuf:"fixed32,8,opt,name=o_float,json=oFloat" json:"o_float,omitempty"`
  67         ODouble          *float64 `protobuf:"fixed64,9,opt,name=o_double,json=oDouble" json:"o_double,omitempty"`
  68         OString          *string  `protobuf:"bytes,10,opt,name=o_string,json=oString" json:"o_string,omitempty"`
  69         OBytes           []byte   `protobuf:"bytes,11,opt,name=o_bytes,json=oBytes" json:"o_bytes,omitempty"`
  70         XXX_unrecognized []byte   `json:"-"`
  71 }
  72
  73 func (m *Simple) Reset()                    { *m = Simple{} }
  74 func (m *Simple) String() string            { return proto.CompactTextString(m) }
  75 func (*Simple) ProtoMessage()               {}
  76 func (*Simple) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  77
  78 func (m *Simple) GetOBool() bool {
  79         if m != nil && m.OBool != nil {
  80                 return *m.OBool
  81         }
  82         return false
  83 }
  84
  85 func (m *Simple) GetOInt32() int32 {
  86         if m != nil && m.OInt32 != nil {
  87                 return *m.OInt32
  88         }
  89         return 0
  90 }
  91
  92 func (m *Simple) GetOInt64() int64 {
  93         if m != nil && m.OInt64 != nil {
  94                 return *m.OInt64
  95         }
  96         return 0
  97 }
  98
  99 func (m *Simple) GetOUint32() uint32 {
 100         if m != nil && m.OUint32 != nil {
 101                 return *m.OUint32
 102         }
 103         return 0
 104 }
 105
 106 func (m *Simple) GetOUint64() uint64 {
 107         if m != nil && m.OUint64 != nil {
 108                 return *m.OUint64
 109         }
 110         return 0
 111 }
 112
 113 func (m *Simple) GetOSint32() int32 {
 114         if m != nil && m.OSint32 != nil {
 115                 return *m.OSint32
 116         }
 117         return 0
 118 }
 119
 120 func (m *Simple) GetOSint64() int64 {
 121         if m != nil && m.OSint64 != nil {
 122                 return *m.OSint64
 123         }
 124         return 0
 125 }
 126
 127 func (m *Simple) GetOFloat() float32 {
 128         if m != nil && m.OFloat != nil {
 129                 return *m.OFloat
 130         }
 131         return 0
 132 }
 133
 134 func (m *Simple) GetODouble() float64 {
 135         if m != nil && m.ODouble != nil {
 136                 return *m.ODouble
 137         }
 138         return 0
 139 }
 140
 141 func (m *Simple) GetOString() string {
 142         if m != nil && m.OString != nil {
 143                 return *m.OString
 144         }
 145         return ""
 146 }
 147
 148 func (m *Simple) GetOBytes() []byte {
 149         if m != nil {
 150                 return m.OBytes
 151         }
 152         return nil
 153 }
 154
 155 // Test message for holding special non-finites primitives.
 156 type NonFinites struct {
 157         FNan             *float32 `protobuf:"fixed32,1,opt,name=f_nan,json=fNan" json:"f_nan,omitempty"`
 158         FPinf            *float32 `protobuf:"fixed32,2,opt,name=f_pinf,json=fPinf" json:"f_pinf,omitempty"`
 159         FNinf            *float32 `protobuf:"fixed32,3,opt,name=f_ninf,json=fNinf" json:"f_ninf,omitempty"`
 160         DNan             *float64 `protobuf:"fixed64,4,opt,name=d_nan,json=dNan" json:"d_nan,omitempty"`
 161         DPinf            *float64 `protobuf:"fixed64,5,opt,name=d_pinf,json=dPinf" json:"d_pinf,omitempty"`
 162         DNinf            *float64 `protobuf:"fixed64,6,opt,name=d_ninf,json=dNinf" json:"d_ninf,omitempty"`
 163         XXX_unrecognized []byte   `json:"-"`
 164 }
 165
 166 func (m *NonFinites) Reset()                    { *m = NonFinites{} }
 167 func (m *NonFinites) String() string            { return proto.CompactTextString(m) }
 168 func (*NonFinites) ProtoMessage()               {}
 169 func (*NonFinites) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
 170
 171 func (m *NonFinites) GetFNan() float32 {
 172         if m != nil && m.FNan != nil {
 173                 return *m.FNan
 174         }
 175         return 0
 176 }
 177
 178 func (m *NonFinites) GetFPinf() float32 {
 179         if m != nil && m.FPinf != nil {
 180                 return *m.FPinf
 181         }
 182         return 0
 183 }
 184
 185 func (m *NonFinites) GetFNinf() float32 {
 186         if m != nil && m.FNinf != nil {
 187                 return *m.FNinf
 188         }
 189         return 0
 190 }
 191
 192 func (m *NonFinites) GetDNan() float64 {
 193         if m != nil && m.DNan != nil {
 194                 return *m.DNan
 195         }
 196         return 0
 197 }
 198
 199 func (m *NonFinites) GetDPinf() float64 {
 200         if m != nil && m.DPinf != nil {
 201                 return *m.DPinf
 202         }
 203         return 0
 204 }
 205
 206 func (m *NonFinites) GetDNinf() float64 {
 207         if m != nil && m.DNinf != nil {
 208                 return *m.DNinf
 209         }
 210         return 0
 211 }
 212
 213 // Test message for holding repeated primitives.
 214 type Repeats struct {
 215         RBool            []bool    `protobuf:"varint,1,rep,name=r_bool,json=rBool" json:"r_bool,omitempty"`
 216         RInt32           []int32   `protobuf:"varint,2,rep,name=r_int32,json=rInt32" json:"r_int32,omitempty"`
 217         RInt64           []int64   `protobuf:"varint,3,rep,name=r_int64,json=rInt64" json:"r_int64,omitempty"`
 218         RUint32          []uint32  `protobuf:"varint,4,rep,name=r_uint32,json=rUint32" json:"r_uint32,omitempty"`
 219         RUint64          []uint64  `protobuf:"varint,5,rep,name=r_uint64,json=rUint64" json:"r_uint64,omitempty"`
 220         RSint32          []int32   `protobuf:"zigzag32,6,rep,name=r_sint32,json=rSint32" json:"r_sint32,omitempty"`
 221         RSint64          []int64   `protobuf:"zigzag64,7,rep,name=r_sint64,json=rSint64" json:"r_sint64,omitempty"`
 222         RFloat           []float32 `protobuf:"fixed32,8,rep,name=r_float,json=rFloat" json:"r_float,omitempty"`
 223         RDouble          []float64 `protobuf:"fixed64,9,rep,name=r_double,json=rDouble" json:"r_double,omitempty"`
 224         RString          []string  `protobuf:"bytes,10,rep,name=r_string,json=rString" json:"r_string,omitempty"`
 225         RBytes           [][]byte  `protobuf:"bytes,11,rep,name=r_bytes,json=rBytes" json:"r_bytes,omitempty"`
 226         XXX_unrecognized []byte    `json:"-"`
 227 }
 228
 229 func (m *Repeats) Reset()                    { *m = Repeats{} }
 230 func (m *Repeats) String() string            { return proto.CompactTextString(m) }
 231 func (*Repeats) ProtoMessage()               {}
 232 func (*Repeats) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
 233
 234 func (m *Repeats) GetRBool() []bool {
 235         if m != nil {
 236                 return m.RBool
 237         }
 238         return nil
 239 }
 240
 241 func (m *Repeats) GetRInt32() []int32 {
 242         if m != nil {
 243                 return m.RInt32
 244         }
 245         return nil
 246 }
 247
 248 func (m *Repeats) GetRInt64() []int64 {
 249         if m != nil {
 250                 return m.RInt64
 251         }
 252         return nil
 253 }
 254
 255 func (m *Repeats) GetRUint32() []uint32 {
 256         if m != nil {
 257                 return m.RUint32
 258         }
 259         return nil
 260 }
 261
 262 func (m *Repeats) GetRUint64() []uint64 {
 263         if m != nil {
 264                 return m.RUint64
 265         }
 266         return nil
 267 }
 268
 269 func (m *Repeats) GetRSint32() []int32 {
 270         if m != nil {
 271                 return m.RSint32
 272         }
 273         return nil
 274 }
 275
 276 func (m *Repeats) GetRSint64() []int64 {
 277         if m != nil {
 278                 return m.RSint64
 279         }
 280         return nil
 281 }
 282
 283 func (m *Repeats) GetRFloat() []float32 {
 284         if m != nil {
 285                 return m.RFloat
 286         }
 287         return nil
 288 }
 289
 290 func (m *Repeats) GetRDouble() []float64 {
 291         if m != nil {
 292                 return m.RDouble
 293         }
 294         return nil
 295 }
 296
 297 func (m *Repeats) GetRString() []string {
 298         if m != nil {
 299                 return m.RString
 300         }
 301         return nil
 302 }
 303
 304 func (m *Repeats) GetRBytes() [][]byte {
 305         if m != nil {
 306                 return m.RBytes
 307         }
 308         return nil
 309 }
 310
 311 // Test message for holding enums and nested messages.
 312 type Widget struct {
 313         Color            *Widget_Color  `protobuf:"varint,1,opt,name=color,enum=jsonpb.Widget_Color" json:"color,omitempty"`
 314         RColor           []Widget_Color `protobuf:"varint,2,rep,name=r_color,json=rColor,enum=jsonpb.Widget_Color" json:"r_color,omitempty"`
 315         Simple           *Simple        `protobuf:"bytes,10,opt,name=simple" json:"simple,omitempty"`
 316         RSimple          []*Simple      `protobuf:"bytes,11,rep,name=r_simple,json=rSimple" json:"r_simple,omitempty"`
 317         Repeats          *Repeats       `protobuf:"bytes,20,opt,name=repeats" json:"repeats,omitempty"`
 318         RRepeats         []*Repeats     `protobuf:"bytes,21,rep,name=r_repeats,json=rRepeats" json:"r_repeats,omitempty"`
 319         XXX_unrecognized []byte         `json:"-"`
 320 }
 321
 322 func (m *Widget) Reset()                    { *m = Widget{} }
 323 func (m *Widget) String() string            { return proto.CompactTextString(m) }
 324 func (*Widget) ProtoMessage()               {}
 325 func (*Widget) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 326
 327 func (m *Widget) GetColor() Widget_Color {
 328         if m != nil && m.Color != nil {
 329                 return *m.Color
 330         }
 331         return Widget_RED
 332 }
 333
 334 func (m *Widget) GetRColor() []Widget_Color {
 335         if m != nil {
 336                 return m.RColor
 337         }
 338         return nil
 339 }
 340
 341 func (m *Widget) GetSimple() *Simple {
 342         if m != nil {
 343                 return m.Simple
 344         }
 345         return nil
 346 }
 347
 348 func (m *Widget) GetRSimple() []*Simple {
 349         if m != nil {
 350                 return m.RSimple
 351         }
 352         return nil
 353 }
 354
 355 func (m *Widget) GetRepeats() *Repeats {
 356         if m != nil {
 357                 return m.Repeats
 358         }
 359         return nil
 360 }
 361
 362 func (m *Widget) GetRRepeats() []*Repeats {
 363         if m != nil {
 364                 return m.RRepeats
 365         }
 366         return nil
 367 }
 368
 369 type Maps struct {
 370         MInt64Str        map[int64]string `protobuf:"bytes,1,rep,name=m_int64_str,json=mInt64Str" json:"m_int64_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
 371         MBoolSimple      map[bool]*Simple `protobuf:"bytes,2,rep,name=m_bool_simple,json=mBoolSimple" json:"m_bool_simple,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
 372         XXX_unrecognized []byte           `json:"-"`
 373 }
 374
 375 func (m *Maps) Reset()                    { *m = Maps{} }
 376 func (m *Maps) String() string            { return proto.CompactTextString(m) }
 377 func (*Maps) ProtoMessage()               {}
 378 func (*Maps) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 379
 380 func (m *Maps) GetMInt64Str() map[int64]string {
 381         if m != nil {
 382                 return m.MInt64Str
 383         }
 384         return nil
 385 }
 386
 387 func (m *Maps) GetMBoolSimple() map[bool]*Simple {
 388         if m != nil {
 389                 return m.MBoolSimple
 390         }
 391         return nil
 392 }
 393
 394 type MsgWithOneof struct {
 395         // Types that are valid to be assigned to Union:
 396         //      *MsgWithOneof_Title
 397         //      *MsgWithOneof_Salary
 398         //      *MsgWithOneof_Country
 399         //      *MsgWithOneof_HomeAddress
 400         Union            isMsgWithOneof_Union `protobuf_oneof:"union"`
 401         XXX_unrecognized []byte               `json:"-"`
 402 }
 403
 404 func (m *MsgWithOneof) Reset()                    { *m = MsgWithOneof{} }
 405 func (m *MsgWithOneof) String() string            { return proto.CompactTextString(m) }
 406 func (*MsgWithOneof) ProtoMessage()               {}
 407 func (*MsgWithOneof) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
 408
 409 type isMsgWithOneof_Union interface {
 410         isMsgWithOneof_Union()
 411 }
 412
 413 type MsgWithOneof_Title struct {
 414         Title string `protobuf:"bytes,1,opt,name=title,oneof"`
 415 }
 416 type MsgWithOneof_Salary struct {
 417         Salary int64 `protobuf:"varint,2,opt,name=salary,oneof"`
 418 }
 419 type MsgWithOneof_Country struct {
 420         Country string `protobuf:"bytes,3,opt,name=Country,oneof"`
 421 }
 422 type MsgWithOneof_HomeAddress struct {
 423         HomeAddress string `protobuf:"bytes,4,opt,name=home_address,json=homeAddress,oneof"`
 424 }
 425
 426 func (*MsgWithOneof_Title) isMsgWithOneof_Union()       {}
 427 func (*MsgWithOneof_Salary) isMsgWithOneof_Union()      {}
 428 func (*MsgWithOneof_Country) isMsgWithOneof_Union()     {}
 429 func (*MsgWithOneof_HomeAddress) isMsgWithOneof_Union() {}
 430
 431 func (m *MsgWithOneof) GetUnion() isMsgWithOneof_Union {
 432         if m != nil {
 433                 return m.Union
 434         }
 435         return nil
 436 }
 437
 438 func (m *MsgWithOneof) GetTitle() string {
 439         if x, ok := m.GetUnion().(*MsgWithOneof_Title); ok {
 440                 return x.Title
 441         }
 442         return ""
 443 }
 444
 445 func (m *MsgWithOneof) GetSalary() int64 {
 446         if x, ok := m.GetUnion().(*MsgWithOneof_Salary); ok {
 447                 return x.Salary
 448         }
 449         return 0
 450 }
 451
 452 func (m *MsgWithOneof) GetCountry() string {
 453         if x, ok := m.GetUnion().(*MsgWithOneof_Country); ok {
 454                 return x.Country
 455         }
 456         return ""
 457 }
 458
 459 func (m *MsgWithOneof) GetHomeAddress() string {
 460         if x, ok := m.GetUnion().(*MsgWithOneof_HomeAddress); ok {
 461                 return x.HomeAddress
 462         }
 463         return ""
 464 }
 465
 466 // XXX_OneofFuncs is for the internal use of the proto package.
 467 func (*MsgWithOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 468         return _MsgWithOneof_OneofMarshaler, _MsgWithOneof_OneofUnmarshaler, _MsgWithOneof_OneofSizer, []interface{}{
 469                 (*MsgWithOneof_Title)(nil),
 470                 (*MsgWithOneof_Salary)(nil),
 471                 (*MsgWithOneof_Country)(nil),
 472                 (*MsgWithOneof_HomeAddress)(nil),
 473         }
 474 }
 475
 476 func _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 477         m := msg.(*MsgWithOneof)
 478         // union
 479         switch x := m.Union.(type) {
 480         case *MsgWithOneof_Title:
 481                 b.EncodeVarint(1<<3 | proto.WireBytes)
 482                 b.EncodeStringBytes(x.Title)
 483         case *MsgWithOneof_Salary:
 484                 b.EncodeVarint(2<<3 | proto.WireVarint)
 485                 b.EncodeVarint(uint64(x.Salary))
 486         case *MsgWithOneof_Country:
 487                 b.EncodeVarint(3<<3 | proto.WireBytes)
 488                 b.EncodeStringBytes(x.Country)
 489         case *MsgWithOneof_HomeAddress:
 490                 b.EncodeVarint(4<<3 | proto.WireBytes)
 491                 b.EncodeStringBytes(x.HomeAddress)
 492         case nil:
 493         default:
 494                 return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x)
 495         }
 496         return nil
 497 }
 498
 499 func _MsgWithOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 500         m := msg.(*MsgWithOneof)
 501         switch tag {
 502         case 1: // union.title
 503                 if wire != proto.WireBytes {
 504                         return true, proto.ErrInternalBadWireType
 505                 }
 506                 x, err := b.DecodeStringBytes()
 507                 m.Union = &MsgWithOneof_Title{x}
 508                 return true, err
 509         case 2: // union.salary
 510                 if wire != proto.WireVarint {
 511                         return true, proto.ErrInternalBadWireType
 512                 }
 513                 x, err := b.DecodeVarint()
 514                 m.Union = &MsgWithOneof_Salary{int64(x)}
 515                 return true, err
 516         case 3: // union.Country
 517                 if wire != proto.WireBytes {
 518                         return true, proto.ErrInternalBadWireType
 519                 }
 520                 x, err := b.DecodeStringBytes()
 521                 m.Union = &MsgWithOneof_Country{x}
 522                 return true, err
 523         case 4: // union.home_address
 524                 if wire != proto.WireBytes {
 525                         return true, proto.ErrInternalBadWireType
 526                 }
 527                 x, err := b.DecodeStringBytes()
 528                 m.Union = &MsgWithOneof_HomeAddress{x}
 529                 return true, err
 530         default:
 531                 return false, nil
 532         }
 533 }
 534
 535 func _MsgWithOneof_OneofSizer(msg proto.Message) (n int) {
 536         m := msg.(*MsgWithOneof)
 537         // union
 538         switch x := m.Union.(type) {
 539         case *MsgWithOneof_Title:
 540                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 541                 n += proto.SizeVarint(uint64(len(x.Title)))
 542                 n += len(x.Title)
 543         case *MsgWithOneof_Salary:
 544                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 545                 n += proto.SizeVarint(uint64(x.Salary))
 546         case *MsgWithOneof_Country:
 547                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 548                 n += proto.SizeVarint(uint64(len(x.Country)))
 549                 n += len(x.Country)
 550         case *MsgWithOneof_HomeAddress:
 551                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 552                 n += proto.SizeVarint(uint64(len(x.HomeAddress)))
 553                 n += len(x.HomeAddress)
 554         case nil:
 555         default:
 556                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 557         }
 558         return n
 559 }
 560
 561 type Real struct {
 562         Value                        *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
 563         proto.XXX_InternalExtensions `json:"-"`
 564         XXX_unrecognized             []byte `json:"-"`
 565 }
 566
 567 func (m *Real) Reset()                    { *m = Real{} }
 568 func (m *Real) String() string            { return proto.CompactTextString(m) }
 569 func (*Real) ProtoMessage()               {}
 570 func (*Real) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
 571
 572 var extRange_Real = []proto.ExtensionRange{
 573         {100, 536870911},
 574 }
 575
 576 func (*Real) ExtensionRangeArray() []proto.ExtensionRange {
 577         return extRange_Real
 578 }
 579
 580 func (m *Real) GetValue() float64 {
 581         if m != nil && m.Value != nil {
 582                 return *m.Value
 583         }
 584         return 0
 585 }
 586
 587 type Complex struct {
 588         Imaginary                    *float64 `protobuf:"fixed64,1,opt,name=imaginary" json:"imaginary,omitempty"`
 589         proto.XXX_InternalExtensions `json:"-"`
 590         XXX_unrecognized             []byte `json:"-"`
 591 }
 592
 593 func (m *Complex) Reset()                    { *m = Complex{} }
 594 func (m *Complex) String() string            { return proto.CompactTextString(m) }
 595 func (*Complex) ProtoMessage()               {}
 596 func (*Complex) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
 597
 598 var extRange_Complex = []proto.ExtensionRange{
 599         {100, 536870911},
 600 }
 601
 602 func (*Complex) ExtensionRangeArray() []proto.ExtensionRange {
 603         return extRange_Complex
 604 }
 605
 606 func (m *Complex) GetImaginary() float64 {
 607         if m != nil && m.Imaginary != nil {
 608                 return *m.Imaginary
 609         }
 610         return 0
 611 }
 612
 613 var E_Complex_RealExtension = &proto.ExtensionDesc{
 614         ExtendedType:  (*Real)(nil),
 615         ExtensionType: (*Complex)(nil),
 616         Field:         123,
 617         Name:          "jsonpb.Complex.real_extension",
 618         Tag:           "bytes,123,opt,name=real_extension,json=realExtension",
 619         Filename:      "test_objects.proto",
 620 }
 621
 622 type KnownTypes struct {
 623         An               *google_protobuf.Any          `protobuf:"bytes,14,opt,name=an" json:"an,omitempty"`
 624         Dur              *google_protobuf1.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
 625         St               *google_protobuf2.Struct      `protobuf:"bytes,12,opt,name=st" json:"st,omitempty"`
 626         Ts               *google_protobuf3.Timestamp   `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
 627         Lv               *google_protobuf2.ListValue   `protobuf:"bytes,15,opt,name=lv" json:"lv,omitempty"`
 628         Val              *google_protobuf2.Value       `protobuf:"bytes,16,opt,name=val" json:"val,omitempty"`
 629         Dbl              *google_protobuf4.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
 630         Flt              *google_protobuf4.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
 631         I64              *google_protobuf4.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
 632         U64              *google_protobuf4.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
 633         I32              *google_protobuf4.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
 634         U32              *google_protobuf4.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
 635         Bool             *google_protobuf4.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
 636         Str              *google_protobuf4.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
 637         Bytes            *google_protobuf4.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
 638         XXX_unrecognized []byte                        `json:"-"`
 639 }
 640
 641 func (m *KnownTypes) Reset()                    { *m = KnownTypes{} }
 642 func (m *KnownTypes) String() string            { return proto.CompactTextString(m) }
 643 func (*KnownTypes) ProtoMessage()               {}
 644 func (*KnownTypes) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
 645
 646 func (m *KnownTypes) GetAn() *google_protobuf.Any {
 647         if m != nil {
 648                 return m.An
 649         }
 650         return nil
 651 }
 652
 653 func (m *KnownTypes) GetDur() *google_protobuf1.Duration {
 654         if m != nil {
 655                 return m.Dur
 656         }
 657         return nil
 658 }
 659
 660 func (m *KnownTypes) GetSt() *google_protobuf2.Struct {
 661         if m != nil {
 662                 return m.St
 663         }
 664         return nil
 665 }
 666
 667 func (m *KnownTypes) GetTs() *google_protobuf3.Timestamp {
 668         if m != nil {
 669                 return m.Ts
 670         }
 671         return nil
 672 }
 673
 674 func (m *KnownTypes) GetLv() *google_protobuf2.ListValue {
 675         if m != nil {
 676                 return m.Lv
 677         }
 678         return nil
 679 }
 680
 681 func (m *KnownTypes) GetVal() *google_protobuf2.Value {
 682         if m != nil {
 683                 return m.Val
 684         }
 685         return nil
 686 }
 687
 688 func (m *KnownTypes) GetDbl() *google_protobuf4.DoubleValue {
 689         if m != nil {
 690                 return m.Dbl
 691         }
 692         return nil
 693 }
 694
 695 func (m *KnownTypes) GetFlt() *google_protobuf4.FloatValue {
 696         if m != nil {
 697                 return m.Flt
 698         }
 699         return nil
 700 }
 701
 702 func (m *KnownTypes) GetI64() *google_protobuf4.Int64Value {
 703         if m != nil {
 704                 return m.I64
 705         }
 706         return nil
 707 }
 708
 709 func (m *KnownTypes) GetU64() *google_protobuf4.UInt64Value {
 710         if m != nil {
 711                 return m.U64
 712         }
 713         return nil
 714 }
 715
 716 func (m *KnownTypes) GetI32() *google_protobuf4.Int32Value {
 717         if m != nil {
 718                 return m.I32
 719         }
 720         return nil
 721 }
 722
 723 func (m *KnownTypes) GetU32() *google_protobuf4.UInt32Value {
 724         if m != nil {
 725                 return m.U32
 726         }
 727         return nil
 728 }
 729
 730 func (m *KnownTypes) GetBool() *google_protobuf4.BoolValue {
 731         if m != nil {
 732                 return m.Bool
 733         }
 734         return nil
 735 }
 736
 737 func (m *KnownTypes) GetStr() *google_protobuf4.StringValue {
 738         if m != nil {
 739                 return m.Str
 740         }
 741         return nil
 742 }
 743
 744 func (m *KnownTypes) GetBytes() *google_protobuf4.BytesValue {
 745         if m != nil {
 746                 return m.Bytes
 747         }
 748         return nil
 749 }
 750
 751 var E_Name = &proto.ExtensionDesc{
 752         ExtendedType:  (*Real)(nil),
 753         ExtensionType: (*string)(nil),
 754         Field:         124,
 755         Name:          "jsonpb.name",
 756         Tag:           "bytes,124,opt,name=name",
 757         Filename:      "test_objects.proto",
 758 }
 759
 760 func init() {
 761         proto.RegisterType((*Simple)(nil), "jsonpb.Simple")
 762         proto.RegisterType((*NonFinites)(nil), "jsonpb.NonFinites")
 763         proto.RegisterType((*Repeats)(nil), "jsonpb.Repeats")
 764         proto.RegisterType((*Widget)(nil), "jsonpb.Widget")
 765         proto.RegisterType((*Maps)(nil), "jsonpb.Maps")
 766         proto.RegisterType((*MsgWithOneof)(nil), "jsonpb.MsgWithOneof")
 767         proto.RegisterType((*Real)(nil), "jsonpb.Real")
 768         proto.RegisterType((*Complex)(nil), "jsonpb.Complex")
 769         proto.RegisterType((*KnownTypes)(nil), "jsonpb.KnownTypes")
 770         proto.RegisterEnum("jsonpb.Widget_Color", Widget_Color_name, Widget_Color_value)
 771         proto.RegisterExtension(E_Complex_RealExtension)
 772         proto.RegisterExtension(E_Name)
 773 }
 774
 775 func init() { proto.RegisterFile("test_objects.proto", fileDescriptor1) }
 776
 777 var fileDescriptor1 = []byte{
 778         // 1160 bytes of a gzipped FileDescriptorProto
 779         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x95, 0x41, 0x73, 0xdb, 0x44,
 780         0x14, 0xc7, 0x23, 0xc9, 0x92, 0xed, 0x75, 0x92, 0x9a, 0x6d, 0xda, 0x2a, 0x26, 0x80, 0xc6, 0x94,
 781         0x22, 0x0a, 0x75, 0x07, 0xc7, 0xe3, 0x61, 0x0a, 0x97, 0xa4, 0x71, 0x29, 0x43, 0x13, 0x98, 0x4d,
 782         0x43, 0x8f, 0x1e, 0x39, 0x5a, 0xbb, 0x2a, 0xf2, 0xae, 0x67, 0x77, 0x95, 0xd4, 0x03, 0x87, 0x9c,
 783         0x39, 0x32, 0x7c, 0x05, 0xf8, 0x08, 0x1c, 0xf8, 0x74, 0xcc, 0xdb, 0x95, 0xac, 0xc4, 0x8e, 0x4f,
 784         0xf1, 0x7b, 0xef, 0xff, 0xfe, 0x59, 0xed, 0x6f, 0x77, 0x1f, 0xc2, 0x8a, 0x4a, 0x35, 0xe4, 0xa3,
 785         0x77, 0xf4, 0x5c, 0xc9, 0xce, 0x4c, 0x70, 0xc5, 0xb1, 0xf7, 0x4e, 0x72, 0x36, 0x1b, 0xb5, 0x76,
 786         0x27, 0x9c, 0x4f, 0x52, 0xfa, 0x54, 0x67, 0x47, 0xd9, 0xf8, 0x69, 0xc4, 0xe6, 0x46, 0xd2, 0xfa,
 787         0x78, 0xb9, 0x14, 0x67, 0x22, 0x52, 0x09, 0x67, 0x79, 0x7d, 0x6f, 0xb9, 0x2e, 0x95, 0xc8, 0xce,
 788         0x55, 0x5e, 0xfd, 0x64, 0xb9, 0xaa, 0x92, 0x29, 0x95, 0x2a, 0x9a, 0xce, 0xd6, 0xd9, 0x5f, 0x8a,
 789         0x68, 0x36, 0xa3, 0x22, 0x5f, 0x61, 0xfb, 0x6f, 0x1b, 0x79, 0xa7, 0xc9, 0x74, 0x96, 0x52, 0x7c,
 790         0x0f, 0x79, 0x7c, 0x38, 0xe2, 0x3c, 0xf5, 0xad, 0xc0, 0x0a, 0x6b, 0xc4, 0xe5, 0x87, 0x9c, 0xa7,
 791         0xf8, 0x01, 0xaa, 0xf2, 0x61, 0xc2, 0xd4, 0x7e, 0xd7, 0xb7, 0x03, 0x2b, 0x74, 0x89, 0xc7, 0x7f,
 792         0x80, 0x68, 0x51, 0xe8, 0xf7, 0x7c, 0x27, 0xb0, 0x42, 0xc7, 0x14, 0xfa, 0x3d, 0xbc, 0x8b, 0x6a,
 793         0x7c, 0x98, 0x99, 0x96, 0x4a, 0x60, 0x85, 0x5b, 0xa4, 0xca, 0xcf, 0x74, 0x58, 0x96, 0xfa, 0x3d,
 794         0xdf, 0x0d, 0xac, 0xb0, 0x92, 0x97, 0x8a, 0x2e, 0x69, 0xba, 0xbc, 0xc0, 0x0a, 0x3f, 0x20, 0x55,
 795         0x7e, 0x7a, 0xad, 0x4b, 0x9a, 0xae, 0x6a, 0x60, 0x85, 0x38, 0x2f, 0xf5, 0x7b, 0x66, 0x11, 0xe3,
 796         0x94, 0x47, 0xca, 0xaf, 0x05, 0x56, 0x68, 0x13, 0x8f, 0xbf, 0x80, 0xc8, 0xf4, 0xc4, 0x3c, 0x1b,
 797         0xa5, 0xd4, 0xaf, 0x07, 0x56, 0x68, 0x91, 0x2a, 0x3f, 0xd2, 0x61, 0x6e, 0xa7, 0x44, 0xc2, 0x26,
 798         0x3e, 0x0a, 0xac, 0xb0, 0x0e, 0x76, 0x3a, 0x34, 0x76, 0xa3, 0xb9, 0xa2, 0xd2, 0x6f, 0x04, 0x56,
 799         0xb8, 0x49, 0x3c, 0x7e, 0x08, 0x51, 0xfb, 0x4f, 0x0b, 0xa1, 0x13, 0xce, 0x5e, 0x24, 0x2c, 0x51,
 800         0x54, 0xe2, 0xbb, 0xc8, 0x1d, 0x0f, 0x59, 0xc4, 0xf4, 0x56, 0xd9, 0xa4, 0x32, 0x3e, 0x89, 0x18,
 801         0x6c, 0xe0, 0x78, 0x38, 0x4b, 0xd8, 0x58, 0x6f, 0x94, 0x4d, 0xdc, 0xf1, 0xcf, 0x09, 0x1b, 0x9b,
 802         0x34, 0x83, 0xb4, 0x93, 0xa7, 0x4f, 0x20, 0x7d, 0x17, 0xb9, 0xb1, 0xb6, 0xa8, 0xe8, 0xd5, 0x55,
 803         0xe2, 0xdc, 0x22, 0x36, 0x16, 0xae, 0xce, 0xba, 0x71, 0x61, 0x11, 0x1b, 0x0b, 0x2f, 0x4f, 0x83,
 804         0x45, 0xfb, 0x1f, 0x1b, 0x55, 0x09, 0x9d, 0xd1, 0x48, 0x49, 0x90, 0x88, 0x82, 0x9e, 0x03, 0xf4,
 805         0x44, 0x41, 0x4f, 0x2c, 0xe8, 0x39, 0x40, 0x4f, 0x2c, 0xe8, 0x89, 0x05, 0x3d, 0x07, 0xe8, 0x89,
 806         0x05, 0x3d, 0x51, 0xd2, 0x73, 0x80, 0x9e, 0x28, 0xe9, 0x89, 0x92, 0x9e, 0x03, 0xf4, 0x44, 0x49,
 807         0x4f, 0x94, 0xf4, 0x1c, 0xa0, 0x27, 0x4e, 0xaf, 0x75, 0x2d, 0xe8, 0x39, 0x40, 0x4f, 0x94, 0xf4,
 808         0xc4, 0x82, 0x9e, 0x03, 0xf4, 0xc4, 0x82, 0x9e, 0x28, 0xe9, 0x39, 0x40, 0x4f, 0x94, 0xf4, 0x44,
 809         0x49, 0xcf, 0x01, 0x7a, 0xa2, 0xa4, 0x27, 0x16, 0xf4, 0x1c, 0xa0, 0x27, 0x0c, 0xbd, 0x7f, 0x6d,
 810         0xe4, 0xbd, 0x49, 0xe2, 0x09, 0x55, 0xf8, 0x31, 0x72, 0xcf, 0x79, 0xca, 0x85, 0x26, 0xb7, 0xdd,
 811         0xdd, 0xe9, 0x98, 0x2b, 0xda, 0x31, 0xe5, 0xce, 0x73, 0xa8, 0x11, 0x23, 0xc1, 0x4f, 0xc0, 0xcf,
 812         0xa8, 0x61, 0xf3, 0xd6, 0xa9, 0x3d, 0xa1, 0xff, 0xe2, 0x47, 0xc8, 0x93, 0xfa, 0x2a, 0xe9, 0x53,
 813         0xd5, 0xe8, 0x6e, 0x17, 0x6a, 0x73, 0xc1, 0x48, 0x5e, 0xc5, 0x5f, 0x98, 0x0d, 0xd1, 0x4a, 0x58,
 814         0xe7, 0xaa, 0x12, 0x36, 0x28, 0x97, 0x56, 0x85, 0x01, 0xec, 0xef, 0x68, 0xcf, 0x3b, 0x85, 0x32,
 815         0xe7, 0x4e, 0x8a, 0x3a, 0xfe, 0x0a, 0xd5, 0xc5, 0xb0, 0x10, 0xdf, 0xd3, 0xb6, 0x2b, 0xe2, 0x9a,
 816         0xc8, 0x7f, 0xb5, 0x3f, 0x43, 0xae, 0x59, 0x74, 0x15, 0x39, 0x64, 0x70, 0xd4, 0xdc, 0xc0, 0x75,
 817         0xe4, 0x7e, 0x4f, 0x06, 0x83, 0x93, 0xa6, 0x85, 0x6b, 0xa8, 0x72, 0xf8, 0xea, 0x6c, 0xd0, 0xb4,
 818         0xdb, 0x7f, 0xd9, 0xa8, 0x72, 0x1c, 0xcd, 0x24, 0xfe, 0x16, 0x35, 0xa6, 0xe6, 0xb8, 0xc0, 0xde,
 819         0xeb, 0x33, 0xd6, 0xe8, 0x7e, 0x58, 0xf8, 0x83, 0xa4, 0x73, 0xac, 0xcf, 0xcf, 0xa9, 0x12, 0x03,
 820         0xa6, 0xc4, 0x9c, 0xd4, 0xa7, 0x45, 0x8c, 0x0f, 0xd0, 0xd6, 0x54, 0x9f, 0xcd, 0xe2, 0xab, 0x6d,
 821         0xdd, 0xfe, 0xd1, 0xcd, 0x76, 0x38, 0xaf, 0xe6, 0xb3, 0x8d, 0x41, 0x63, 0x5a, 0x66, 0x5a, 0xdf,
 822         0xa1, 0xed, 0x9b, 0xfe, 0xb8, 0x89, 0x9c, 0x5f, 0xe9, 0x5c, 0x63, 0x74, 0x08, 0xfc, 0xc4, 0x3b,
 823         0xc8, 0xbd, 0x88, 0xd2, 0x8c, 0xea, 0xeb, 0x57, 0x27, 0x26, 0x78, 0x66, 0x7f, 0x63, 0xb5, 0x4e,
 824         0x50, 0x73, 0xd9, 0xfe, 0x7a, 0x7f, 0xcd, 0xf4, 0x3f, 0xbc, 0xde, 0xbf, 0x0a, 0xa5, 0xf4, 0x6b,
 825         0xff, 0x61, 0xa1, 0xcd, 0x63, 0x39, 0x79, 0x93, 0xa8, 0xb7, 0x3f, 0x31, 0xca, 0xc7, 0xf8, 0x3e,
 826         0x72, 0x55, 0xa2, 0x52, 0xaa, 0xed, 0xea, 0x2f, 0x37, 0x88, 0x09, 0xb1, 0x8f, 0x3c, 0x19, 0xa5,
 827         0x91, 0x98, 0x6b, 0x4f, 0xe7, 0xe5, 0x06, 0xc9, 0x63, 0xdc, 0x42, 0xd5, 0xe7, 0x3c, 0x83, 0x95,
 828         0xe8, 0x67, 0x01, 0x7a, 0x8a, 0x04, 0xfe, 0x14, 0x6d, 0xbe, 0xe5, 0x53, 0x3a, 0x8c, 0xe2, 0x58,
 829         0x50, 0x29, 0xf5, 0x0b, 0x01, 0x82, 0x06, 0x64, 0x0f, 0x4c, 0xf2, 0xb0, 0x8a, 0xdc, 0x8c, 0x25,
 830         0x9c, 0xb5, 0x1f, 0xa1, 0x0a, 0xa1, 0x51, 0x5a, 0x7e, 0xbe, 0x65, 0xde, 0x08, 0x1d, 0x3c, 0xae,
 831         0xd5, 0xe2, 0xe6, 0xd5, 0xd5, 0xd5, 0x95, 0xdd, 0xbe, 0x84, 0xff, 0x08, 0x5f, 0xf2, 0x1e, 0xef,
 832         0xa1, 0x7a, 0x32, 0x8d, 0x26, 0x09, 0x83, 0x95, 0x19, 0x79, 0x99, 0x28, 0x5b, 0xba, 0x47, 0x68,
 833         0x5b, 0xd0, 0x28, 0x1d, 0xd2, 0xf7, 0x8a, 0x32, 0x99, 0x70, 0x86, 0x37, 0xcb, 0x23, 0x15, 0xa5,
 834         0xfe, 0x6f, 0x37, 0xcf, 0x64, 0x6e, 0x4f, 0xb6, 0xa0, 0x69, 0x50, 0xf4, 0xb4, 0xff, 0x73, 0x11,
 835         0xfa, 0x91, 0xf1, 0x4b, 0xf6, 0x7a, 0x3e, 0xa3, 0x12, 0x3f, 0x44, 0x76, 0xc4, 0xfc, 0x6d, 0xdd,
 836         0xba, 0xd3, 0x31, 0xf3, 0xa9, 0x53, 0xcc, 0xa7, 0xce, 0x01, 0x9b, 0x13, 0x3b, 0x62, 0xf8, 0x4b,
 837         0xe4, 0xc4, 0x99, 0xb9, 0xa5, 0x8d, 0xee, 0xee, 0x8a, 0xec, 0x28, 0x9f, 0x92, 0x04, 0x54, 0xf8,
 838         0x73, 0x64, 0x4b, 0xe5, 0x6f, 0x6a, 0xed, 0x83, 0x15, 0xed, 0xa9, 0x9e, 0x98, 0xc4, 0x96, 0x70,
 839         0xfb, 0x6d, 0x25, 0x73, 0xbe, 0xad, 0x15, 0xe1, 0xeb, 0x62, 0x78, 0x12, 0x5b, 0x49, 0xd0, 0xa6,
 840         0x17, 0xfe, 0x9d, 0x35, 0xda, 0x57, 0x89, 0x54, 0xbf, 0xc0, 0x0e, 0x13, 0x3b, 0xbd, 0xc0, 0x21,
 841         0x72, 0x2e, 0xa2, 0xd4, 0x6f, 0x6a, 0xf1, 0xfd, 0x15, 0xb1, 0x11, 0x82, 0x04, 0x77, 0x90, 0x13,
 842         0x8f, 0x52, 0xcd, 0xbc, 0xd1, 0xdd, 0x5b, 0xfd, 0x2e, 0xfd, 0xc8, 0xe5, 0xfa, 0x78, 0x94, 0xe2,
 843         0x27, 0xc8, 0x19, 0xa7, 0x4a, 0x1f, 0x01, 0xb8, 0x70, 0xcb, 0x7a, 0xfd, 0x5c, 0xe6, 0xf2, 0x71,
 844         0xaa, 0x40, 0x9e, 0xe4, 0xb3, 0xf5, 0x36, 0xb9, 0xbe, 0x42, 0xb9, 0x3c, 0xe9, 0xf7, 0x60, 0x35,
 845         0x59, 0xbf, 0xa7, 0xa7, 0xca, 0x6d, 0xab, 0x39, 0xbb, 0xae, 0xcf, 0xfa, 0x3d, 0x6d, 0xbf, 0xdf,
 846         0xd5, 0x43, 0x78, 0x8d, 0xfd, 0x7e, 0xb7, 0xb0, 0xdf, 0xef, 0x6a, 0xfb, 0xfd, 0xae, 0x9e, 0xcc,
 847         0xeb, 0xec, 0x17, 0xfa, 0x4c, 0xeb, 0x2b, 0x7a, 0x84, 0xd5, 0xd7, 0x6c, 0x3a, 0xdc, 0x61, 0x23,
 848         0xd7, 0x3a, 0xf0, 0x87, 0xd7, 0x08, 0xad, 0xf1, 0x37, 0x63, 0x21, 0xf7, 0x97, 0x4a, 0xe0, 0xaf,
 849         0x91, 0x5b, 0x0e, 0xf7, 0xdb, 0x3e, 0x40, 0x8f, 0x0b, 0xd3, 0x60, 0x94, 0xcf, 0x02, 0x54, 0x61,
 850         0xd1, 0x94, 0x2e, 0x1d, 0xfc, 0xdf, 0xf5, 0x0b, 0xa3, 0x2b, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff,
 851         0xd5, 0x39, 0x32, 0x09, 0xf9, 0x09, 0x00, 0x00,
 852 }