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  }