ceph/src/jaegertracing/thrift/lib/go/thrift/serializer_types_test.go

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements. See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership. The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License. You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing,
  13  * software distributed under the License is distributed on an
  14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15  * KIND, either express or implied. See the License for the
  16  * specific language governing permissions and limitations
  17  * under the License.
  18  */
  19
  20 package thrift
  21
  22 // Autogenerated by Thrift Compiler (FIXME)
  23 // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  24
  25 /* THE FOLLOWING THRIFT FILE WAS USED TO CREATE THIS
  26
  27 enum MyTestEnum {
  28         FIRST = 1,
  29         SECOND = 2,
  30         THIRD = 3,
  31         FOURTH = 4,
  32 }
  33
  34 struct MyTestStruct {
  35         1: bool on,
  36         2: byte b,
  37         3: i16 int16,
  38         4: i32 int32,
  39         5: i64 int64,
  40         6: double d,
  41         7: string st,
  42         8: binary bin,
  43         9: map<string, string> stringMap,
  44         10: list<string> stringList,
  45         11: set<string> stringSet,
  46         12: MyTestEnum e,
  47 }
  48 */
  49
  50 import (
  51         "fmt"
  52 )
  53
  54 // (needed to ensure safety because of naive import list construction.)
  55 var _ = ZERO
  56 var _ = fmt.Printf
  57
  58 var GoUnusedProtection__ int
  59
  60 type MyTestEnum int64
  61
  62 const (
  63         MyTestEnum_FIRST  MyTestEnum = 1
  64         MyTestEnum_SECOND MyTestEnum = 2
  65         MyTestEnum_THIRD  MyTestEnum = 3
  66         MyTestEnum_FOURTH MyTestEnum = 4
  67 )
  68
  69 func (p MyTestEnum) String() string {
  70         switch p {
  71         case MyTestEnum_FIRST:
  72                 return "FIRST"
  73         case MyTestEnum_SECOND:
  74                 return "SECOND"
  75         case MyTestEnum_THIRD:
  76                 return "THIRD"
  77         case MyTestEnum_FOURTH:
  78                 return "FOURTH"
  79         }
  80         return "<UNSET>"
  81 }
  82
  83 func MyTestEnumFromString(s string) (MyTestEnum, error) {
  84         switch s {
  85         case "FIRST":
  86                 return MyTestEnum_FIRST, nil
  87         case "SECOND":
  88                 return MyTestEnum_SECOND, nil
  89         case "THIRD":
  90                 return MyTestEnum_THIRD, nil
  91         case "FOURTH":
  92                 return MyTestEnum_FOURTH, nil
  93         }
  94         return MyTestEnum(0), fmt.Errorf("not a valid MyTestEnum string")
  95 }
  96
  97 func MyTestEnumPtr(v MyTestEnum) *MyTestEnum { return &v }
  98
  99 type MyTestStruct struct {
 100         On         bool                `thrift:"on,1" json:"on"`
 101         B          int8                `thrift:"b,2" json:"b"`
 102         Int16      int16               `thrift:"int16,3" json:"int16"`
 103         Int32      int32               `thrift:"int32,4" json:"int32"`
 104         Int64      int64               `thrift:"int64,5" json:"int64"`
 105         D          float64             `thrift:"d,6" json:"d"`
 106         St         string              `thrift:"st,7" json:"st"`
 107         Bin        []byte              `thrift:"bin,8" json:"bin"`
 108         StringMap  map[string]string   `thrift:"stringMap,9" json:"stringMap"`
 109         StringList []string            `thrift:"stringList,10" json:"stringList"`
 110         StringSet  map[string]struct{} `thrift:"stringSet,11" json:"stringSet"`
 111         E          MyTestEnum          `thrift:"e,12" json:"e"`
 112 }
 113
 114 func NewMyTestStruct() *MyTestStruct {
 115         return &MyTestStruct{}
 116 }
 117
 118 func (p *MyTestStruct) GetOn() bool {
 119         return p.On
 120 }
 121
 122 func (p *MyTestStruct) GetB() int8 {
 123         return p.B
 124 }
 125
 126 func (p *MyTestStruct) GetInt16() int16 {
 127         return p.Int16
 128 }
 129
 130 func (p *MyTestStruct) GetInt32() int32 {
 131         return p.Int32
 132 }
 133
 134 func (p *MyTestStruct) GetInt64() int64 {
 135         return p.Int64
 136 }
 137
 138 func (p *MyTestStruct) GetD() float64 {
 139         return p.D
 140 }
 141
 142 func (p *MyTestStruct) GetSt() string {
 143         return p.St
 144 }
 145
 146 func (p *MyTestStruct) GetBin() []byte {
 147         return p.Bin
 148 }
 149
 150 func (p *MyTestStruct) GetStringMap() map[string]string {
 151         return p.StringMap
 152 }
 153
 154 func (p *MyTestStruct) GetStringList() []string {
 155         return p.StringList
 156 }
 157
 158 func (p *MyTestStruct) GetStringSet() map[string]struct{} {
 159         return p.StringSet
 160 }
 161
 162 func (p *MyTestStruct) GetE() MyTestEnum {
 163         return p.E
 164 }
 165 func (p *MyTestStruct) Read(iprot TProtocol) error {
 166         if _, err := iprot.ReadStructBegin(); err != nil {
 167                 return PrependError(fmt.Sprintf("%T read error: ", p), err)
 168         }
 169         for {
 170                 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
 171                 if err != nil {
 172                         return PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 173                 }
 174                 if fieldTypeId == STOP {
 175                         break
 176                 }
 177                 switch fieldId {
 178                 case 1:
 179                         if err := p.readField1(iprot); err != nil {
 180                                 return err
 181                         }
 182                 case 2:
 183                         if err := p.readField2(iprot); err != nil {
 184                                 return err
 185                         }
 186                 case 3:
 187                         if err := p.readField3(iprot); err != nil {
 188                                 return err
 189                         }
 190                 case 4:
 191                         if err := p.readField4(iprot); err != nil {
 192                                 return err
 193                         }
 194                 case 5:
 195                         if err := p.readField5(iprot); err != nil {
 196                                 return err
 197                         }
 198                 case 6:
 199                         if err := p.readField6(iprot); err != nil {
 200                                 return err
 201                         }
 202                 case 7:
 203                         if err := p.readField7(iprot); err != nil {
 204                                 return err
 205                         }
 206                 case 8:
 207                         if err := p.readField8(iprot); err != nil {
 208                                 return err
 209                         }
 210                 case 9:
 211                         if err := p.readField9(iprot); err != nil {
 212                                 return err
 213                         }
 214                 case 10:
 215                         if err := p.readField10(iprot); err != nil {
 216                                 return err
 217                         }
 218                 case 11:
 219                         if err := p.readField11(iprot); err != nil {
 220                                 return err
 221                         }
 222                 case 12:
 223                         if err := p.readField12(iprot); err != nil {
 224                                 return err
 225                         }
 226                 default:
 227                         if err := iprot.Skip(fieldTypeId); err != nil {
 228                                 return err
 229                         }
 230                 }
 231                 if err := iprot.ReadFieldEnd(); err != nil {
 232                         return err
 233                 }
 234         }
 235         if err := iprot.ReadStructEnd(); err != nil {
 236                 return PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 237         }
 238         return nil
 239 }
 240
 241 func (p *MyTestStruct) readField1(iprot TProtocol) error {
 242         if v, err := iprot.ReadBool(); err != nil {
 243                 return PrependError("error reading field 1: ", err)
 244         } else {
 245                 p.On = v
 246         }
 247         return nil
 248 }
 249
 250 func (p *MyTestStruct) readField2(iprot TProtocol) error {
 251         if v, err := iprot.ReadByte(); err != nil {
 252                 return PrependError("error reading field 2: ", err)
 253         } else {
 254                 temp := int8(v)
 255                 p.B = temp
 256         }
 257         return nil
 258 }
 259
 260 func (p *MyTestStruct) readField3(iprot TProtocol) error {
 261         if v, err := iprot.ReadI16(); err != nil {
 262                 return PrependError("error reading field 3: ", err)
 263         } else {
 264                 p.Int16 = v
 265         }
 266         return nil
 267 }
 268
 269 func (p *MyTestStruct) readField4(iprot TProtocol) error {
 270         if v, err := iprot.ReadI32(); err != nil {
 271                 return PrependError("error reading field 4: ", err)
 272         } else {
 273                 p.Int32 = v
 274         }
 275         return nil
 276 }
 277
 278 func (p *MyTestStruct) readField5(iprot TProtocol) error {
 279         if v, err := iprot.ReadI64(); err != nil {
 280                 return PrependError("error reading field 5: ", err)
 281         } else {
 282                 p.Int64 = v
 283         }
 284         return nil
 285 }
 286
 287 func (p *MyTestStruct) readField6(iprot TProtocol) error {
 288         if v, err := iprot.ReadDouble(); err != nil {
 289                 return PrependError("error reading field 6: ", err)
 290         } else {
 291                 p.D = v
 292         }
 293         return nil
 294 }
 295
 296 func (p *MyTestStruct) readField7(iprot TProtocol) error {
 297         if v, err := iprot.ReadString(); err != nil {
 298                 return PrependError("error reading field 7: ", err)
 299         } else {
 300                 p.St = v
 301         }
 302         return nil
 303 }
 304
 305 func (p *MyTestStruct) readField8(iprot TProtocol) error {
 306         if v, err := iprot.ReadBinary(); err != nil {
 307                 return PrependError("error reading field 8: ", err)
 308         } else {
 309                 p.Bin = v
 310         }
 311         return nil
 312 }
 313
 314 func (p *MyTestStruct) readField9(iprot TProtocol) error {
 315         _, _, size, err := iprot.ReadMapBegin()
 316         if err != nil {
 317                 return PrependError("error reading map begin: ", err)
 318         }
 319         tMap := make(map[string]string, size)
 320         p.StringMap = tMap
 321         for i := 0; i < size; i++ {
 322                 var _key0 string
 323                 if v, err := iprot.ReadString(); err != nil {
 324                         return PrependError("error reading field 0: ", err)
 325                 } else {
 326                         _key0 = v
 327                 }
 328                 var _val1 string
 329                 if v, err := iprot.ReadString(); err != nil {
 330                         return PrependError("error reading field 0: ", err)
 331                 } else {
 332                         _val1 = v
 333                 }
 334                 p.StringMap[_key0] = _val1
 335         }
 336         if err := iprot.ReadMapEnd(); err != nil {
 337                 return PrependError("error reading map end: ", err)
 338         }
 339         return nil
 340 }
 341
 342 func (p *MyTestStruct) readField10(iprot TProtocol) error {
 343         _, size, err := iprot.ReadListBegin()
 344         if err != nil {
 345                 return PrependError("error reading list begin: ", err)
 346         }
 347         tSlice := make([]string, 0, size)
 348         p.StringList = tSlice
 349         for i := 0; i < size; i++ {
 350                 var _elem2 string
 351                 if v, err := iprot.ReadString(); err != nil {
 352                         return PrependError("error reading field 0: ", err)
 353                 } else {
 354                         _elem2 = v
 355                 }
 356                 p.StringList = append(p.StringList, _elem2)
 357         }
 358         if err := iprot.ReadListEnd(); err != nil {
 359                 return PrependError("error reading list end: ", err)
 360         }
 361         return nil
 362 }
 363
 364 func (p *MyTestStruct) readField11(iprot TProtocol) error {
 365         _, size, err := iprot.ReadSetBegin()
 366         if err != nil {
 367                 return PrependError("error reading set begin: ", err)
 368         }
 369         tSet := make(map[string]struct{}, size)
 370         p.StringSet = tSet
 371         for i := 0; i < size; i++ {
 372                 var _elem3 string
 373                 if v, err := iprot.ReadString(); err != nil {
 374                         return PrependError("error reading field 0: ", err)
 375                 } else {
 376                         _elem3 = v
 377                 }
 378                 p.StringSet[_elem3] = struct{}{}
 379         }
 380         if err := iprot.ReadSetEnd(); err != nil {
 381                 return PrependError("error reading set end: ", err)
 382         }
 383         return nil
 384 }
 385
 386 func (p *MyTestStruct) readField12(iprot TProtocol) error {
 387         if v, err := iprot.ReadI32(); err != nil {
 388                 return PrependError("error reading field 12: ", err)
 389         } else {
 390                 temp := MyTestEnum(v)
 391                 p.E = temp
 392         }
 393         return nil
 394 }
 395
 396 func (p *MyTestStruct) Write(oprot TProtocol) error {
 397         if err := oprot.WriteStructBegin("MyTestStruct"); err != nil {
 398                 return PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 399         }
 400         if err := p.writeField1(oprot); err != nil {
 401                 return err
 402         }
 403         if err := p.writeField2(oprot); err != nil {
 404                 return err
 405         }
 406         if err := p.writeField3(oprot); err != nil {
 407                 return err
 408         }
 409         if err := p.writeField4(oprot); err != nil {
 410                 return err
 411         }
 412         if err := p.writeField5(oprot); err != nil {
 413                 return err
 414         }
 415         if err := p.writeField6(oprot); err != nil {
 416                 return err
 417         }
 418         if err := p.writeField7(oprot); err != nil {
 419                 return err
 420         }
 421         if err := p.writeField8(oprot); err != nil {
 422                 return err
 423         }
 424         if err := p.writeField9(oprot); err != nil {
 425                 return err
 426         }
 427         if err := p.writeField10(oprot); err != nil {
 428                 return err
 429         }
 430         if err := p.writeField11(oprot); err != nil {
 431                 return err
 432         }
 433         if err := p.writeField12(oprot); err != nil {
 434                 return err
 435         }
 436         if err := oprot.WriteFieldStop(); err != nil {
 437                 return PrependError("write field stop error: ", err)
 438         }
 439         if err := oprot.WriteStructEnd(); err != nil {
 440                 return PrependError("write struct stop error: ", err)
 441         }
 442         return nil
 443 }
 444
 445 func (p *MyTestStruct) writeField1(oprot TProtocol) (err error) {
 446         if err := oprot.WriteFieldBegin("on", BOOL, 1); err != nil {
 447                 return PrependError(fmt.Sprintf("%T write field begin error 1:on: ", p), err)
 448         }
 449         if err := oprot.WriteBool(bool(p.On)); err != nil {
 450                 return PrependError(fmt.Sprintf("%T.on (1) field write error: ", p), err)
 451         }
 452         if err := oprot.WriteFieldEnd(); err != nil {
 453                 return PrependError(fmt.Sprintf("%T write field end error 1:on: ", p), err)
 454         }
 455         return err
 456 }
 457
 458 func (p *MyTestStruct) writeField2(oprot TProtocol) (err error) {
 459         if err := oprot.WriteFieldBegin("b", BYTE, 2); err != nil {
 460                 return PrependError(fmt.Sprintf("%T write field begin error 2:b: ", p), err)
 461         }
 462         if err := oprot.WriteByte(int8(p.B)); err != nil {
 463                 return PrependError(fmt.Sprintf("%T.b (2) field write error: ", p), err)
 464         }
 465         if err := oprot.WriteFieldEnd(); err != nil {
 466                 return PrependError(fmt.Sprintf("%T write field end error 2:b: ", p), err)
 467         }
 468         return err
 469 }
 470
 471 func (p *MyTestStruct) writeField3(oprot TProtocol) (err error) {
 472         if err := oprot.WriteFieldBegin("int16", I16, 3); err != nil {
 473                 return PrependError(fmt.Sprintf("%T write field begin error 3:int16: ", p), err)
 474         }
 475         if err := oprot.WriteI16(int16(p.Int16)); err != nil {
 476                 return PrependError(fmt.Sprintf("%T.int16 (3) field write error: ", p), err)
 477         }
 478         if err := oprot.WriteFieldEnd(); err != nil {
 479                 return PrependError(fmt.Sprintf("%T write field end error 3:int16: ", p), err)
 480         }
 481         return err
 482 }
 483
 484 func (p *MyTestStruct) writeField4(oprot TProtocol) (err error) {
 485         if err := oprot.WriteFieldBegin("int32", I32, 4); err != nil {
 486                 return PrependError(fmt.Sprintf("%T write field begin error 4:int32: ", p), err)
 487         }
 488         if err := oprot.WriteI32(int32(p.Int32)); err != nil {
 489                 return PrependError(fmt.Sprintf("%T.int32 (4) field write error: ", p), err)
 490         }
 491         if err := oprot.WriteFieldEnd(); err != nil {
 492                 return PrependError(fmt.Sprintf("%T write field end error 4:int32: ", p), err)
 493         }
 494         return err
 495 }
 496
 497 func (p *MyTestStruct) writeField5(oprot TProtocol) (err error) {
 498         if err := oprot.WriteFieldBegin("int64", I64, 5); err != nil {
 499                 return PrependError(fmt.Sprintf("%T write field begin error 5:int64: ", p), err)
 500         }
 501         if err := oprot.WriteI64(int64(p.Int64)); err != nil {
 502                 return PrependError(fmt.Sprintf("%T.int64 (5) field write error: ", p), err)
 503         }
 504         if err := oprot.WriteFieldEnd(); err != nil {
 505                 return PrependError(fmt.Sprintf("%T write field end error 5:int64: ", p), err)
 506         }
 507         return err
 508 }
 509
 510 func (p *MyTestStruct) writeField6(oprot TProtocol) (err error) {
 511         if err := oprot.WriteFieldBegin("d", DOUBLE, 6); err != nil {
 512                 return PrependError(fmt.Sprintf("%T write field begin error 6:d: ", p), err)
 513         }
 514         if err := oprot.WriteDouble(float64(p.D)); err != nil {
 515                 return PrependError(fmt.Sprintf("%T.d (6) field write error: ", p), err)
 516         }
 517         if err := oprot.WriteFieldEnd(); err != nil {
 518                 return PrependError(fmt.Sprintf("%T write field end error 6:d: ", p), err)
 519         }
 520         return err
 521 }
 522
 523 func (p *MyTestStruct) writeField7(oprot TProtocol) (err error) {
 524         if err := oprot.WriteFieldBegin("st", STRING, 7); err != nil {
 525                 return PrependError(fmt.Sprintf("%T write field begin error 7:st: ", p), err)
 526         }
 527         if err := oprot.WriteString(string(p.St)); err != nil {
 528                 return PrependError(fmt.Sprintf("%T.st (7) field write error: ", p), err)
 529         }
 530         if err := oprot.WriteFieldEnd(); err != nil {
 531                 return PrependError(fmt.Sprintf("%T write field end error 7:st: ", p), err)
 532         }
 533         return err
 534 }
 535
 536 func (p *MyTestStruct) writeField8(oprot TProtocol) (err error) {
 537         if err := oprot.WriteFieldBegin("bin", STRING, 8); err != nil {
 538                 return PrependError(fmt.Sprintf("%T write field begin error 8:bin: ", p), err)
 539         }
 540         if err := oprot.WriteBinary(p.Bin); err != nil {
 541                 return PrependError(fmt.Sprintf("%T.bin (8) field write error: ", p), err)
 542         }
 543         if err := oprot.WriteFieldEnd(); err != nil {
 544                 return PrependError(fmt.Sprintf("%T write field end error 8:bin: ", p), err)
 545         }
 546         return err
 547 }
 548
 549 func (p *MyTestStruct) writeField9(oprot TProtocol) (err error) {
 550         if err := oprot.WriteFieldBegin("stringMap", MAP, 9); err != nil {
 551                 return PrependError(fmt.Sprintf("%T write field begin error 9:stringMap: ", p), err)
 552         }
 553         if err := oprot.WriteMapBegin(STRING, STRING, len(p.StringMap)); err != nil {
 554                 return PrependError("error writing map begin: ", err)
 555         }
 556         for k, v := range p.StringMap {
 557                 if err := oprot.WriteString(string(k)); err != nil {
 558                         return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 559                 }
 560                 if err := oprot.WriteString(string(v)); err != nil {
 561                         return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 562                 }
 563         }
 564         if err := oprot.WriteMapEnd(); err != nil {
 565                 return PrependError("error writing map end: ", err)
 566         }
 567         if err := oprot.WriteFieldEnd(); err != nil {
 568                 return PrependError(fmt.Sprintf("%T write field end error 9:stringMap: ", p), err)
 569         }
 570         return err
 571 }
 572
 573 func (p *MyTestStruct) writeField10(oprot TProtocol) (err error) {
 574         if err := oprot.WriteFieldBegin("stringList", LIST, 10); err != nil {
 575                 return PrependError(fmt.Sprintf("%T write field begin error 10:stringList: ", p), err)
 576         }
 577         if err := oprot.WriteListBegin(STRING, len(p.StringList)); err != nil {
 578                 return PrependError("error writing list begin: ", err)
 579         }
 580         for _, v := range p.StringList {
 581                 if err := oprot.WriteString(string(v)); err != nil {
 582                         return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 583                 }
 584         }
 585         if err := oprot.WriteListEnd(); err != nil {
 586                 return PrependError("error writing list end: ", err)
 587         }
 588         if err := oprot.WriteFieldEnd(); err != nil {
 589                 return PrependError(fmt.Sprintf("%T write field end error 10:stringList: ", p), err)
 590         }
 591         return err
 592 }
 593
 594 func (p *MyTestStruct) writeField11(oprot TProtocol) (err error) {
 595         if err := oprot.WriteFieldBegin("stringSet", SET, 11); err != nil {
 596                 return PrependError(fmt.Sprintf("%T write field begin error 11:stringSet: ", p), err)
 597         }
 598         if err := oprot.WriteSetBegin(STRING, len(p.StringSet)); err != nil {
 599                 return PrependError("error writing set begin: ", err)
 600         }
 601         for v := range p.StringSet {
 602                 if err := oprot.WriteString(string(v)); err != nil {
 603                         return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 604                 }
 605         }
 606         if err := oprot.WriteSetEnd(); err != nil {
 607                 return PrependError("error writing set end: ", err)
 608         }
 609         if err := oprot.WriteFieldEnd(); err != nil {
 610                 return PrependError(fmt.Sprintf("%T write field end error 11:stringSet: ", p), err)
 611         }
 612         return err
 613 }
 614
 615 func (p *MyTestStruct) writeField12(oprot TProtocol) (err error) {
 616         if err := oprot.WriteFieldBegin("e", I32, 12); err != nil {
 617                 return PrependError(fmt.Sprintf("%T write field begin error 12:e: ", p), err)
 618         }
 619         if err := oprot.WriteI32(int32(p.E)); err != nil {
 620                 return PrependError(fmt.Sprintf("%T.e (12) field write error: ", p), err)
 621         }
 622         if err := oprot.WriteFieldEnd(); err != nil {
 623                 return PrependError(fmt.Sprintf("%T write field end error 12:e: ", p), err)
 624         }
 625         return err
 626 }
 627
 628 func (p *MyTestStruct) String() string {
 629         if p == nil {
 630                 return "<nil>"
 631         }
 632         return fmt.Sprintf("MyTestStruct(%+v)", *p)
 633 }