github.com/cloudwego/dynamicgo@v0.2.6-0.20240519101509-707f41b6b834/thrift/base/base.go (about) 1 /** 2 * Copyright 2023 CloudWeGo Authors. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package base 18 19 import ( 20 "fmt" 21 "strings" 22 23 "github.com/apache/thrift/lib/go/thrift" 24 ) 25 26 type TrafficEnv struct { 27 Open bool `thrift:"Open,1" json:"Open"` 28 Env string `thrift:"Env,2" json:"Env"` 29 } 30 31 func NewTrafficEnv() *TrafficEnv { 32 return &TrafficEnv{ 33 34 Open: false, 35 Env: "", 36 } 37 } 38 39 func (p *TrafficEnv) GetOpen() (v bool) { 40 return p.Open 41 } 42 43 func (p *TrafficEnv) GetEnv() (v string) { 44 return p.Env 45 } 46 func (p *TrafficEnv) SetOpen(val bool) { 47 p.Open = val 48 } 49 func (p *TrafficEnv) SetEnv(val string) { 50 p.Env = val 51 } 52 53 var fieldIDToName_TrafficEnv = map[int16]string{ 54 1: "Open", 55 2: "Env", 56 } 57 58 func (p *TrafficEnv) Read(iprot thrift.TProtocol) (err error) { 59 60 var fieldTypeId thrift.TType 61 var fieldId int16 62 63 if _, err = iprot.ReadStructBegin(); err != nil { 64 goto ReadStructBeginError 65 } 66 67 for { 68 _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() 69 if err != nil { 70 goto ReadFieldBeginError 71 } 72 if fieldTypeId == thrift.STOP { 73 break 74 } 75 76 switch fieldId { 77 case 1: 78 if fieldTypeId == thrift.BOOL { 79 if err = p.ReadField1(iprot); err != nil { 80 goto ReadFieldError 81 } 82 } else { 83 if err = iprot.Skip(fieldTypeId); err != nil { 84 goto SkipFieldError 85 } 86 } 87 case 2: 88 if fieldTypeId == thrift.STRING { 89 if err = p.ReadField2(iprot); err != nil { 90 goto ReadFieldError 91 } 92 } else { 93 if err = iprot.Skip(fieldTypeId); err != nil { 94 goto SkipFieldError 95 } 96 } 97 default: 98 if err = iprot.Skip(fieldTypeId); err != nil { 99 goto SkipFieldError 100 } 101 } 102 103 if err = iprot.ReadFieldEnd(); err != nil { 104 goto ReadFieldEndError 105 } 106 } 107 if err = iprot.ReadStructEnd(); err != nil { 108 goto ReadStructEndError 109 } 110 111 return nil 112 ReadStructBeginError: 113 return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) 114 ReadFieldBeginError: 115 return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) 116 ReadFieldError: 117 return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TrafficEnv[fieldId]), err) 118 SkipFieldError: 119 return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) 120 121 ReadFieldEndError: 122 return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) 123 ReadStructEndError: 124 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 125 } 126 127 func (p *TrafficEnv) ReadField1(iprot thrift.TProtocol) error { 128 if v, err := iprot.ReadBool(); err != nil { 129 return err 130 } else { 131 p.Open = v 132 } 133 return nil 134 } 135 136 func (p *TrafficEnv) ReadField2(iprot thrift.TProtocol) error { 137 if v, err := iprot.ReadString(); err != nil { 138 return err 139 } else { 140 p.Env = v 141 } 142 return nil 143 } 144 145 func (p *TrafficEnv) Write(oprot thrift.TProtocol) (err error) { 146 var fieldId int16 147 if err = oprot.WriteStructBegin("TrafficEnv"); err != nil { 148 goto WriteStructBeginError 149 } 150 if p != nil { 151 if err = p.writeField1(oprot); err != nil { 152 fieldId = 1 153 goto WriteFieldError 154 } 155 if err = p.writeField2(oprot); err != nil { 156 fieldId = 2 157 goto WriteFieldError 158 } 159 160 } 161 if err = oprot.WriteFieldStop(); err != nil { 162 goto WriteFieldStopError 163 } 164 if err = oprot.WriteStructEnd(); err != nil { 165 goto WriteStructEndError 166 } 167 return nil 168 WriteStructBeginError: 169 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 170 WriteFieldError: 171 return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) 172 WriteFieldStopError: 173 return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) 174 WriteStructEndError: 175 return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) 176 } 177 178 func (p *TrafficEnv) writeField1(oprot thrift.TProtocol) (err error) { 179 if err = oprot.WriteFieldBegin("Open", thrift.BOOL, 1); err != nil { 180 goto WriteFieldBeginError 181 } 182 if err := oprot.WriteBool(p.Open); err != nil { 183 return err 184 } 185 if err = oprot.WriteFieldEnd(); err != nil { 186 goto WriteFieldEndError 187 } 188 return nil 189 WriteFieldBeginError: 190 return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) 191 WriteFieldEndError: 192 return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) 193 } 194 195 func (p *TrafficEnv) writeField2(oprot thrift.TProtocol) (err error) { 196 if err = oprot.WriteFieldBegin("Env", thrift.STRING, 2); err != nil { 197 goto WriteFieldBeginError 198 } 199 if err := oprot.WriteString(p.Env); err != nil { 200 return err 201 } 202 if err = oprot.WriteFieldEnd(); err != nil { 203 goto WriteFieldEndError 204 } 205 return nil 206 WriteFieldBeginError: 207 return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) 208 WriteFieldEndError: 209 return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) 210 } 211 212 func (p *TrafficEnv) String() string { 213 if p == nil { 214 return "<nil>" 215 } 216 return fmt.Sprintf("TrafficEnv(%+v)", *p) 217 } 218 219 func (p *TrafficEnv) DeepEqual(ano *TrafficEnv) bool { 220 if p == ano { 221 return true 222 } else if p == nil || ano == nil { 223 return false 224 } 225 if !p.Field1DeepEqual(ano.Open) { 226 return false 227 } 228 if !p.Field2DeepEqual(ano.Env) { 229 return false 230 } 231 return true 232 } 233 234 func (p *TrafficEnv) Field1DeepEqual(src bool) bool { 235 236 if p.Open != src { 237 return false 238 } 239 return true 240 } 241 func (p *TrafficEnv) Field2DeepEqual(src string) bool { 242 243 if strings.Compare(p.Env, src) != 0 { 244 return false 245 } 246 return true 247 } 248 249 type Base struct { 250 LogID string `thrift:"LogID,1" json:"LogID"` 251 Caller string `thrift:"Caller,2" json:"Caller"` 252 Addr string `thrift:"Addr,3" json:"Addr"` 253 Client string `thrift:"Client,4" json:"Client"` 254 TrafficEnv *TrafficEnv `thrift:"TrafficEnv,5" json:"TrafficEnv,omitempty"` 255 Extra map[string]string `thrift:"Extra,6" json:"Extra,omitempty"` 256 } 257 258 func NewBase() *Base { 259 return &Base{ 260 LogID: "", 261 Caller: "", 262 Addr: "", 263 Client: "", 264 Extra: map[string]string{}, 265 } 266 } 267 268 func (p *Base) GetLogID() (v string) { 269 return p.LogID 270 } 271 272 func (p *Base) GetCaller() (v string) { 273 return p.Caller 274 } 275 276 func (p *Base) GetAddr() (v string) { 277 return p.Addr 278 } 279 280 func (p *Base) GetClient() (v string) { 281 return p.Client 282 } 283 284 var Base_TrafficEnv_DEFAULT *TrafficEnv 285 286 func (p *Base) GetTrafficEnv() (v *TrafficEnv) { 287 if !p.IsSetTrafficEnv() { 288 return Base_TrafficEnv_DEFAULT 289 } 290 return p.TrafficEnv 291 } 292 293 var Base_Extra_DEFAULT map[string]string 294 295 func (p *Base) GetExtra() (v map[string]string) { 296 if !p.IsSetExtra() { 297 return Base_Extra_DEFAULT 298 } 299 return p.Extra 300 } 301 func (p *Base) SetLogID(val string) { 302 p.LogID = val 303 } 304 func (p *Base) SetCaller(val string) { 305 p.Caller = val 306 } 307 func (p *Base) SetAddr(val string) { 308 p.Addr = val 309 } 310 func (p *Base) SetClient(val string) { 311 p.Client = val 312 } 313 func (p *Base) SetTrafficEnv(val *TrafficEnv) { 314 p.TrafficEnv = val 315 } 316 func (p *Base) SetExtra(val map[string]string) { 317 p.Extra = val 318 } 319 320 var fieldIDToName_Base = map[int16]string{ 321 1: "LogID", 322 2: "Caller", 323 3: "Addr", 324 4: "Client", 325 5: "TrafficEnv", 326 6: "Extra", 327 } 328 329 func (p *Base) IsSetTrafficEnv() bool { 330 return p.TrafficEnv != nil 331 } 332 333 func (p *Base) IsSetExtra() bool { 334 return p.Extra != nil 335 } 336 337 func (p *Base) Read(iprot thrift.TProtocol) (err error) { 338 339 var fieldTypeId thrift.TType 340 var fieldId int16 341 342 if _, err = iprot.ReadStructBegin(); err != nil { 343 goto ReadStructBeginError 344 } 345 346 for { 347 _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() 348 if err != nil { 349 goto ReadFieldBeginError 350 } 351 if fieldTypeId == thrift.STOP { 352 break 353 } 354 355 switch fieldId { 356 case 1: 357 if fieldTypeId == thrift.STRING { 358 if err = p.ReadField1(iprot); err != nil { 359 goto ReadFieldError 360 } 361 } else { 362 if err = iprot.Skip(fieldTypeId); err != nil { 363 goto SkipFieldError 364 } 365 } 366 case 2: 367 if fieldTypeId == thrift.STRING { 368 if err = p.ReadField2(iprot); err != nil { 369 goto ReadFieldError 370 } 371 } else { 372 if err = iprot.Skip(fieldTypeId); err != nil { 373 goto SkipFieldError 374 } 375 } 376 case 3: 377 if fieldTypeId == thrift.STRING { 378 if err = p.ReadField3(iprot); err != nil { 379 goto ReadFieldError 380 } 381 } else { 382 if err = iprot.Skip(fieldTypeId); err != nil { 383 goto SkipFieldError 384 } 385 } 386 case 4: 387 if fieldTypeId == thrift.STRING { 388 if err = p.ReadField4(iprot); err != nil { 389 goto ReadFieldError 390 } 391 } else { 392 if err = iprot.Skip(fieldTypeId); err != nil { 393 goto SkipFieldError 394 } 395 } 396 case 5: 397 if fieldTypeId == thrift.STRUCT { 398 if err = p.ReadField5(iprot); err != nil { 399 goto ReadFieldError 400 } 401 } else { 402 if err = iprot.Skip(fieldTypeId); err != nil { 403 goto SkipFieldError 404 } 405 } 406 case 6: 407 if fieldTypeId == thrift.MAP { 408 if err = p.ReadField6(iprot); err != nil { 409 goto ReadFieldError 410 } 411 } else { 412 if err = iprot.Skip(fieldTypeId); err != nil { 413 goto SkipFieldError 414 } 415 } 416 default: 417 if err = iprot.Skip(fieldTypeId); err != nil { 418 goto SkipFieldError 419 } 420 } 421 422 if err = iprot.ReadFieldEnd(); err != nil { 423 goto ReadFieldEndError 424 } 425 } 426 if err = iprot.ReadStructEnd(); err != nil { 427 goto ReadStructEndError 428 } 429 430 return nil 431 ReadStructBeginError: 432 return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) 433 ReadFieldBeginError: 434 return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) 435 ReadFieldError: 436 return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Base[fieldId]), err) 437 SkipFieldError: 438 return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) 439 440 ReadFieldEndError: 441 return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) 442 ReadStructEndError: 443 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 444 } 445 446 func (p *Base) ReadField1(iprot thrift.TProtocol) error { 447 if v, err := iprot.ReadString(); err != nil { 448 return err 449 } else { 450 p.LogID = v 451 } 452 return nil 453 } 454 455 func (p *Base) ReadField2(iprot thrift.TProtocol) error { 456 if v, err := iprot.ReadString(); err != nil { 457 return err 458 } else { 459 p.Caller = v 460 } 461 return nil 462 } 463 464 func (p *Base) ReadField3(iprot thrift.TProtocol) error { 465 if v, err := iprot.ReadString(); err != nil { 466 return err 467 } else { 468 p.Addr = v 469 } 470 return nil 471 } 472 473 func (p *Base) ReadField4(iprot thrift.TProtocol) error { 474 if v, err := iprot.ReadString(); err != nil { 475 return err 476 } else { 477 p.Client = v 478 } 479 return nil 480 } 481 482 func (p *Base) ReadField5(iprot thrift.TProtocol) error { 483 p.TrafficEnv = NewTrafficEnv() 484 if err := p.TrafficEnv.Read(iprot); err != nil { 485 return err 486 } 487 return nil 488 } 489 490 func (p *Base) ReadField6(iprot thrift.TProtocol) error { 491 _, _, size, err := iprot.ReadMapBegin() 492 if err != nil { 493 return err 494 } 495 p.Extra = make(map[string]string, size) 496 for i := 0; i < size; i++ { 497 var _key string 498 if v, err := iprot.ReadString(); err != nil { 499 return err 500 } else { 501 _key = v 502 } 503 504 var _val string 505 if v, err := iprot.ReadString(); err != nil { 506 return err 507 } else { 508 _val = v 509 } 510 511 p.Extra[_key] = _val 512 } 513 if err := iprot.ReadMapEnd(); err != nil { 514 return err 515 } 516 return nil 517 } 518 519 func (p *Base) Write(oprot thrift.TProtocol) (err error) { 520 var fieldId int16 521 if err = oprot.WriteStructBegin("Base"); err != nil { 522 goto WriteStructBeginError 523 } 524 if p != nil { 525 if err = p.writeField1(oprot); err != nil { 526 fieldId = 1 527 goto WriteFieldError 528 } 529 if err = p.writeField2(oprot); err != nil { 530 fieldId = 2 531 goto WriteFieldError 532 } 533 if err = p.writeField3(oprot); err != nil { 534 fieldId = 3 535 goto WriteFieldError 536 } 537 if err = p.writeField4(oprot); err != nil { 538 fieldId = 4 539 goto WriteFieldError 540 } 541 if err = p.writeField5(oprot); err != nil { 542 fieldId = 5 543 goto WriteFieldError 544 } 545 if err = p.writeField6(oprot); err != nil { 546 fieldId = 6 547 goto WriteFieldError 548 } 549 550 } 551 if err = oprot.WriteFieldStop(); err != nil { 552 goto WriteFieldStopError 553 } 554 if err = oprot.WriteStructEnd(); err != nil { 555 goto WriteStructEndError 556 } 557 return nil 558 WriteStructBeginError: 559 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 560 WriteFieldError: 561 return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) 562 WriteFieldStopError: 563 return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) 564 WriteStructEndError: 565 return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) 566 } 567 568 func (p *Base) writeField1(oprot thrift.TProtocol) (err error) { 569 if err = oprot.WriteFieldBegin("LogID", thrift.STRING, 1); err != nil { 570 goto WriteFieldBeginError 571 } 572 if err := oprot.WriteString(p.LogID); err != nil { 573 return err 574 } 575 if err = oprot.WriteFieldEnd(); err != nil { 576 goto WriteFieldEndError 577 } 578 return nil 579 WriteFieldBeginError: 580 return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) 581 WriteFieldEndError: 582 return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) 583 } 584 585 func (p *Base) writeField2(oprot thrift.TProtocol) (err error) { 586 if err = oprot.WriteFieldBegin("Caller", thrift.STRING, 2); err != nil { 587 goto WriteFieldBeginError 588 } 589 if err := oprot.WriteString(p.Caller); err != nil { 590 return err 591 } 592 if err = oprot.WriteFieldEnd(); err != nil { 593 goto WriteFieldEndError 594 } 595 return nil 596 WriteFieldBeginError: 597 return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) 598 WriteFieldEndError: 599 return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) 600 } 601 602 func (p *Base) writeField3(oprot thrift.TProtocol) (err error) { 603 if err = oprot.WriteFieldBegin("Addr", thrift.STRING, 3); err != nil { 604 goto WriteFieldBeginError 605 } 606 if err := oprot.WriteString(p.Addr); err != nil { 607 return err 608 } 609 if err = oprot.WriteFieldEnd(); err != nil { 610 goto WriteFieldEndError 611 } 612 return nil 613 WriteFieldBeginError: 614 return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) 615 WriteFieldEndError: 616 return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) 617 } 618 619 func (p *Base) writeField4(oprot thrift.TProtocol) (err error) { 620 if err = oprot.WriteFieldBegin("Client", thrift.STRING, 4); err != nil { 621 goto WriteFieldBeginError 622 } 623 if err := oprot.WriteString(p.Client); err != nil { 624 return err 625 } 626 if err = oprot.WriteFieldEnd(); err != nil { 627 goto WriteFieldEndError 628 } 629 return nil 630 WriteFieldBeginError: 631 return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) 632 WriteFieldEndError: 633 return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) 634 } 635 636 func (p *Base) writeField5(oprot thrift.TProtocol) (err error) { 637 if p.IsSetTrafficEnv() { 638 if err = oprot.WriteFieldBegin("TrafficEnv", thrift.STRUCT, 5); err != nil { 639 goto WriteFieldBeginError 640 } 641 if err := p.TrafficEnv.Write(oprot); err != nil { 642 return err 643 } 644 if err = oprot.WriteFieldEnd(); err != nil { 645 goto WriteFieldEndError 646 } 647 } 648 return nil 649 WriteFieldBeginError: 650 return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) 651 WriteFieldEndError: 652 return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) 653 } 654 655 func (p *Base) writeField6(oprot thrift.TProtocol) (err error) { 656 if p.IsSetExtra() { 657 if err = oprot.WriteFieldBegin("Extra", thrift.MAP, 6); err != nil { 658 goto WriteFieldBeginError 659 } 660 if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Extra)); err != nil { 661 return err 662 } 663 for k, v := range p.Extra { 664 665 if err := oprot.WriteString(k); err != nil { 666 return err 667 } 668 669 if err := oprot.WriteString(v); err != nil { 670 return err 671 } 672 } 673 if err := oprot.WriteMapEnd(); err != nil { 674 return err 675 } 676 if err = oprot.WriteFieldEnd(); err != nil { 677 goto WriteFieldEndError 678 } 679 } 680 return nil 681 WriteFieldBeginError: 682 return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err) 683 WriteFieldEndError: 684 return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err) 685 } 686 687 func (p *Base) String() string { 688 if p == nil { 689 return "<nil>" 690 } 691 return fmt.Sprintf("Base(%+v)", *p) 692 } 693 694 func (p *Base) DeepEqual(ano *Base) bool { 695 if p == ano { 696 return true 697 } else if p == nil || ano == nil { 698 return false 699 } 700 if !p.Field1DeepEqual(ano.LogID) { 701 return false 702 } 703 if !p.Field2DeepEqual(ano.Caller) { 704 return false 705 } 706 if !p.Field3DeepEqual(ano.Addr) { 707 return false 708 } 709 if !p.Field4DeepEqual(ano.Client) { 710 return false 711 } 712 if !p.Field5DeepEqual(ano.TrafficEnv) { 713 return false 714 } 715 if !p.Field6DeepEqual(ano.Extra) { 716 return false 717 } 718 return true 719 } 720 721 func (p *Base) Field1DeepEqual(src string) bool { 722 723 if strings.Compare(p.LogID, src) != 0 { 724 return false 725 } 726 return true 727 } 728 func (p *Base) Field2DeepEqual(src string) bool { 729 730 if strings.Compare(p.Caller, src) != 0 { 731 return false 732 } 733 return true 734 } 735 func (p *Base) Field3DeepEqual(src string) bool { 736 737 if strings.Compare(p.Addr, src) != 0 { 738 return false 739 } 740 return true 741 } 742 func (p *Base) Field4DeepEqual(src string) bool { 743 744 if strings.Compare(p.Client, src) != 0 { 745 return false 746 } 747 return true 748 } 749 func (p *Base) Field5DeepEqual(src *TrafficEnv) bool { 750 751 if !p.TrafficEnv.DeepEqual(src) { 752 return false 753 } 754 return true 755 } 756 func (p *Base) Field6DeepEqual(src map[string]string) bool { 757 758 if len(p.Extra) != len(src) { 759 return false 760 } 761 for k, v := range p.Extra { 762 _src := src[k] 763 if strings.Compare(v, _src) != 0 { 764 return false 765 } 766 } 767 return true 768 } 769 770 type BaseResp struct { 771 StatusMessage string `thrift:"StatusMessage,1" json:"StatusMessage"` 772 StatusCode int32 `thrift:"StatusCode,2" json:"StatusCode"` 773 Extra map[string]string `thrift:"Extra,3" json:"Extra,omitempty"` 774 } 775 776 func NewBaseResp() *BaseResp { 777 return &BaseResp{ 778 779 StatusMessage: "", 780 StatusCode: 0, 781 } 782 } 783 784 func (p *BaseResp) GetStatusMessage() (v string) { 785 return p.StatusMessage 786 } 787 788 func (p *BaseResp) GetStatusCode() (v int32) { 789 return p.StatusCode 790 } 791 792 var BaseResp_Extra_DEFAULT map[string]string 793 794 func (p *BaseResp) GetExtra() (v map[string]string) { 795 if !p.IsSetExtra() { 796 return BaseResp_Extra_DEFAULT 797 } 798 return p.Extra 799 } 800 func (p *BaseResp) SetStatusMessage(val string) { 801 p.StatusMessage = val 802 } 803 func (p *BaseResp) SetStatusCode(val int32) { 804 p.StatusCode = val 805 } 806 func (p *BaseResp) SetExtra(val map[string]string) { 807 p.Extra = val 808 } 809 810 var fieldIDToName_BaseResp = map[int16]string{ 811 1: "StatusMessage", 812 2: "StatusCode", 813 3: "Extra", 814 } 815 816 func (p *BaseResp) IsSetExtra() bool { 817 return p.Extra != nil 818 } 819 820 func (p *BaseResp) Read(iprot thrift.TProtocol) (err error) { 821 822 var fieldTypeId thrift.TType 823 var fieldId int16 824 825 if _, err = iprot.ReadStructBegin(); err != nil { 826 goto ReadStructBeginError 827 } 828 829 for { 830 _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() 831 if err != nil { 832 goto ReadFieldBeginError 833 } 834 if fieldTypeId == thrift.STOP { 835 break 836 } 837 838 switch fieldId { 839 case 1: 840 if fieldTypeId == thrift.STRING { 841 if err = p.ReadField1(iprot); err != nil { 842 goto ReadFieldError 843 } 844 } else { 845 if err = iprot.Skip(fieldTypeId); err != nil { 846 goto SkipFieldError 847 } 848 } 849 case 2: 850 if fieldTypeId == thrift.I32 { 851 if err = p.ReadField2(iprot); err != nil { 852 goto ReadFieldError 853 } 854 } else { 855 if err = iprot.Skip(fieldTypeId); err != nil { 856 goto SkipFieldError 857 } 858 } 859 case 3: 860 if fieldTypeId == thrift.MAP { 861 if err = p.ReadField3(iprot); err != nil { 862 goto ReadFieldError 863 } 864 } else { 865 if err = iprot.Skip(fieldTypeId); err != nil { 866 goto SkipFieldError 867 } 868 } 869 default: 870 if err = iprot.Skip(fieldTypeId); err != nil { 871 goto SkipFieldError 872 } 873 } 874 875 if err = iprot.ReadFieldEnd(); err != nil { 876 goto ReadFieldEndError 877 } 878 } 879 if err = iprot.ReadStructEnd(); err != nil { 880 goto ReadStructEndError 881 } 882 883 return nil 884 ReadStructBeginError: 885 return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) 886 ReadFieldBeginError: 887 return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) 888 ReadFieldError: 889 return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BaseResp[fieldId]), err) 890 SkipFieldError: 891 return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) 892 893 ReadFieldEndError: 894 return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) 895 ReadStructEndError: 896 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 897 } 898 899 func (p *BaseResp) ReadField1(iprot thrift.TProtocol) error { 900 if v, err := iprot.ReadString(); err != nil { 901 return err 902 } else { 903 p.StatusMessage = v 904 } 905 return nil 906 } 907 908 func (p *BaseResp) ReadField2(iprot thrift.TProtocol) error { 909 if v, err := iprot.ReadI32(); err != nil { 910 return err 911 } else { 912 p.StatusCode = v 913 } 914 return nil 915 } 916 917 func (p *BaseResp) ReadField3(iprot thrift.TProtocol) error { 918 _, _, size, err := iprot.ReadMapBegin() 919 if err != nil { 920 return err 921 } 922 p.Extra = make(map[string]string, size) 923 for i := 0; i < size; i++ { 924 var _key string 925 if v, err := iprot.ReadString(); err != nil { 926 return err 927 } else { 928 _key = v 929 } 930 931 var _val string 932 if v, err := iprot.ReadString(); err != nil { 933 return err 934 } else { 935 _val = v 936 } 937 938 p.Extra[_key] = _val 939 } 940 if err := iprot.ReadMapEnd(); err != nil { 941 return err 942 } 943 return nil 944 } 945 946 func (p *BaseResp) Write(oprot thrift.TProtocol) (err error) { 947 var fieldId int16 948 if err = oprot.WriteStructBegin("BaseResp"); err != nil { 949 goto WriteStructBeginError 950 } 951 if p != nil { 952 if err = p.writeField1(oprot); err != nil { 953 fieldId = 1 954 goto WriteFieldError 955 } 956 if err = p.writeField2(oprot); err != nil { 957 fieldId = 2 958 goto WriteFieldError 959 } 960 if err = p.writeField3(oprot); err != nil { 961 fieldId = 3 962 goto WriteFieldError 963 } 964 965 } 966 if err = oprot.WriteFieldStop(); err != nil { 967 goto WriteFieldStopError 968 } 969 if err = oprot.WriteStructEnd(); err != nil { 970 goto WriteStructEndError 971 } 972 return nil 973 WriteStructBeginError: 974 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 975 WriteFieldError: 976 return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) 977 WriteFieldStopError: 978 return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) 979 WriteStructEndError: 980 return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) 981 } 982 983 func (p *BaseResp) writeField1(oprot thrift.TProtocol) (err error) { 984 if err = oprot.WriteFieldBegin("StatusMessage", thrift.STRING, 1); err != nil { 985 goto WriteFieldBeginError 986 } 987 if err := oprot.WriteString(p.StatusMessage); err != nil { 988 return err 989 } 990 if err = oprot.WriteFieldEnd(); err != nil { 991 goto WriteFieldEndError 992 } 993 return nil 994 WriteFieldBeginError: 995 return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) 996 WriteFieldEndError: 997 return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) 998 } 999 1000 func (p *BaseResp) writeField2(oprot thrift.TProtocol) (err error) { 1001 if err = oprot.WriteFieldBegin("StatusCode", thrift.I32, 2); err != nil { 1002 goto WriteFieldBeginError 1003 } 1004 if err := oprot.WriteI32(p.StatusCode); err != nil { 1005 return err 1006 } 1007 if err = oprot.WriteFieldEnd(); err != nil { 1008 goto WriteFieldEndError 1009 } 1010 return nil 1011 WriteFieldBeginError: 1012 return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) 1013 WriteFieldEndError: 1014 return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) 1015 } 1016 1017 func (p *BaseResp) writeField3(oprot thrift.TProtocol) (err error) { 1018 if p.IsSetExtra() { 1019 if err = oprot.WriteFieldBegin("Extra", thrift.MAP, 3); err != nil { 1020 goto WriteFieldBeginError 1021 } 1022 if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Extra)); err != nil { 1023 return err 1024 } 1025 for k, v := range p.Extra { 1026 1027 if err := oprot.WriteString(k); err != nil { 1028 return err 1029 } 1030 1031 if err := oprot.WriteString(v); err != nil { 1032 return err 1033 } 1034 } 1035 if err := oprot.WriteMapEnd(); err != nil { 1036 return err 1037 } 1038 if err = oprot.WriteFieldEnd(); err != nil { 1039 goto WriteFieldEndError 1040 } 1041 } 1042 return nil 1043 WriteFieldBeginError: 1044 return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) 1045 WriteFieldEndError: 1046 return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) 1047 } 1048 1049 func (p *BaseResp) String() string { 1050 if p == nil { 1051 return "<nil>" 1052 } 1053 return fmt.Sprintf("BaseResp(%+v)", *p) 1054 } 1055 1056 func (p *BaseResp) DeepEqual(ano *BaseResp) bool { 1057 if p == ano { 1058 return true 1059 } else if p == nil || ano == nil { 1060 return false 1061 } 1062 if !p.Field1DeepEqual(ano.StatusMessage) { 1063 return false 1064 } 1065 if !p.Field2DeepEqual(ano.StatusCode) { 1066 return false 1067 } 1068 if !p.Field3DeepEqual(ano.Extra) { 1069 return false 1070 } 1071 return true 1072 } 1073 1074 func (p *BaseResp) Field1DeepEqual(src string) bool { 1075 1076 if strings.Compare(p.StatusMessage, src) != 0 { 1077 return false 1078 } 1079 return true 1080 } 1081 func (p *BaseResp) Field2DeepEqual(src int32) bool { 1082 1083 if p.StatusCode != src { 1084 return false 1085 } 1086 return true 1087 } 1088 func (p *BaseResp) Field3DeepEqual(src map[string]string) bool { 1089 1090 if len(p.Extra) != len(src) { 1091 return false 1092 } 1093 for k, v := range p.Extra { 1094 _src := src[k] 1095 if strings.Compare(v, _src) != 0 { 1096 return false 1097 } 1098 } 1099 return true 1100 }