gitee.com/h79/goutils@v1.22.10/thrift/redis_proxy/redis_proxy.go (about)

     1  // Autogenerated by Thrift Compiler (0.13.0)
     2  // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
     3  
     4  package redis_proxy
     5  
     6  import (
     7  	"bytes"
     8  	"context"
     9  	"fmt"
    10  	"github.com/apache/thrift/lib/go/thrift"
    11  	"reflect"
    12  )
    13  
    14  // (needed to ensure safety because of naive import list construction.)
    15  var _ = thrift.ZERO
    16  var _ = fmt.Printf
    17  var _ = context.Background
    18  var _ = reflect.DeepEqual
    19  var _ = bytes.Equal
    20  
    21  // Attributes:
    22  //  - Score
    23  //  - Member
    24  type Z struct {
    25  	Score  float64 `thrift:"score,1" db:"score" json:"score"`
    26  	Member string  `thrift:"member,2" db:"member" json:"member"`
    27  }
    28  
    29  func NewZ() *Z {
    30  	return &Z{}
    31  }
    32  
    33  func (p *Z) GetScore() float64 {
    34  	return p.Score
    35  }
    36  
    37  func (p *Z) GetMember() string {
    38  	return p.Member
    39  }
    40  func (p *Z) Read(ctx context.Context, tp thrift.TProtocol) error {
    41  	if _, err := tp.ReadStructBegin(ctx); err != nil {
    42  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
    43  	}
    44  
    45  	for {
    46  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
    47  		if err != nil {
    48  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    49  		}
    50  		if fieldTypeId == thrift.STOP {
    51  			break
    52  		}
    53  		switch fieldId {
    54  		case 1:
    55  			if fieldTypeId == thrift.DOUBLE {
    56  				if err := p.ReadField1(ctx, tp); err != nil {
    57  					return err
    58  				}
    59  			} else {
    60  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
    61  					return err
    62  				}
    63  			}
    64  		case 2:
    65  			if fieldTypeId == thrift.STRING {
    66  				if err := p.ReadField2(ctx, tp); err != nil {
    67  					return err
    68  				}
    69  			} else {
    70  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
    71  					return err
    72  				}
    73  			}
    74  		default:
    75  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
    76  				return err
    77  			}
    78  		}
    79  		if err := tp.ReadFieldEnd(ctx); err != nil {
    80  			return err
    81  		}
    82  	}
    83  	if err := tp.ReadStructEnd(ctx); err != nil {
    84  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
    85  	}
    86  	return nil
    87  }
    88  
    89  func (p *Z) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
    90  	if v, err := tp.ReadDouble(ctx); err != nil {
    91  		return thrift.PrependError("error reading field 1: ", err)
    92  	} else {
    93  		p.Score = v
    94  	}
    95  	return nil
    96  }
    97  
    98  func (p *Z) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
    99  	if v, err := tp.ReadString(ctx); err != nil {
   100  		return thrift.PrependError("error reading field 2: ", err)
   101  	} else {
   102  		p.Member = v
   103  	}
   104  	return nil
   105  }
   106  
   107  func (p *Z) Write(ctx context.Context, tp thrift.TProtocol) error {
   108  	if err := tp.WriteStructBegin(ctx, "Z"); err != nil {
   109  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
   110  	}
   111  	if p != nil {
   112  		if err := p.writeField1(ctx, tp); err != nil {
   113  			return err
   114  		}
   115  		if err := p.writeField2(ctx, tp); err != nil {
   116  			return err
   117  		}
   118  	}
   119  	if err := tp.WriteFieldStop(ctx); err != nil {
   120  		return thrift.PrependError("write field stop error: ", err)
   121  	}
   122  	if err := tp.WriteStructEnd(ctx); err != nil {
   123  		return thrift.PrependError("write struct stop error: ", err)
   124  	}
   125  	return nil
   126  }
   127  
   128  func (p *Z) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
   129  	if err := tp.WriteFieldBegin(ctx, "score", thrift.DOUBLE, 1); err != nil {
   130  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:score: ", p), err)
   131  	}
   132  	if err := tp.WriteDouble(ctx, float64(p.Score)); err != nil {
   133  		return thrift.PrependError(fmt.Sprintf("%T.score (1) field write error: ", p), err)
   134  	}
   135  	if err := tp.WriteFieldEnd(ctx); err != nil {
   136  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:score: ", p), err)
   137  	}
   138  	return err
   139  }
   140  
   141  func (p *Z) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
   142  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 2); err != nil {
   143  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:member: ", p), err)
   144  	}
   145  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
   146  		return thrift.PrependError(fmt.Sprintf("%T.member (2) field write error: ", p), err)
   147  	}
   148  	if err := tp.WriteFieldEnd(ctx); err != nil {
   149  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:member: ", p), err)
   150  	}
   151  	return err
   152  }
   153  
   154  func (p *Z) String() string {
   155  	if p == nil {
   156  		return "<nil>"
   157  	}
   158  	return fmt.Sprintf("Z(%+v)", *p)
   159  }
   160  
   161  // Attributes:
   162  //  - Code
   163  //  - Msg
   164  //  - Res
   165  type ZResponse struct {
   166  	Code int32  `thrift:"code,1" db:"code" json:"code"`
   167  	Msg  string `thrift:"msg,2" db:"msg" json:"msg"`
   168  	Res  []*Z   `thrift:"res,3" db:"res" json:"res"`
   169  }
   170  
   171  func NewZResponse() *ZResponse {
   172  	return &ZResponse{}
   173  }
   174  
   175  func (p *ZResponse) GetCode() int32 {
   176  	return p.Code
   177  }
   178  
   179  func (p *ZResponse) GetMsg() string {
   180  	return p.Msg
   181  }
   182  
   183  func (p *ZResponse) GetRes() []*Z {
   184  	return p.Res
   185  }
   186  func (p *ZResponse) Read(ctx context.Context, tp thrift.TProtocol) error {
   187  	if _, err := tp.ReadStructBegin(ctx); err != nil {
   188  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
   189  	}
   190  
   191  	for {
   192  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
   193  		if err != nil {
   194  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
   195  		}
   196  		if fieldTypeId == thrift.STOP {
   197  			break
   198  		}
   199  		switch fieldId {
   200  		case 1:
   201  			if fieldTypeId == thrift.I32 {
   202  				if err := p.ReadField1(ctx, tp); err != nil {
   203  					return err
   204  				}
   205  			} else {
   206  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
   207  					return err
   208  				}
   209  			}
   210  		case 2:
   211  			if fieldTypeId == thrift.STRING {
   212  				if err := p.ReadField2(ctx, tp); err != nil {
   213  					return err
   214  				}
   215  			} else {
   216  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
   217  					return err
   218  				}
   219  			}
   220  		case 3:
   221  			if fieldTypeId == thrift.LIST {
   222  				if err := p.ReadField3(ctx, tp); err != nil {
   223  					return err
   224  				}
   225  			} else {
   226  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
   227  					return err
   228  				}
   229  			}
   230  		default:
   231  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
   232  				return err
   233  			}
   234  		}
   235  		if err := tp.ReadFieldEnd(ctx); err != nil {
   236  			return err
   237  		}
   238  	}
   239  	if err := tp.ReadStructEnd(ctx); err != nil {
   240  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
   241  	}
   242  	return nil
   243  }
   244  
   245  func (p *ZResponse) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
   246  	if v, err := tp.ReadI32(ctx); err != nil {
   247  		return thrift.PrependError("error reading field 1: ", err)
   248  	} else {
   249  		p.Code = v
   250  	}
   251  	return nil
   252  }
   253  
   254  func (p *ZResponse) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
   255  	if v, err := tp.ReadString(ctx); err != nil {
   256  		return thrift.PrependError("error reading field 2: ", err)
   257  	} else {
   258  		p.Msg = v
   259  	}
   260  	return nil
   261  }
   262  
   263  func (p *ZResponse) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
   264  	_, size, err := tp.ReadListBegin(ctx)
   265  	if err != nil {
   266  		return thrift.PrependError("error reading list begin: ", err)
   267  	}
   268  	tSlice := make([]*Z, 0, size)
   269  	p.Res = tSlice
   270  	for i := 0; i < size; i++ {
   271  		_elem8 := &Z{}
   272  		if err := _elem8.Read(ctx, tp); err != nil {
   273  			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem8), err)
   274  		}
   275  		p.Res = append(p.Res, _elem8)
   276  	}
   277  	if err := tp.ReadListEnd(ctx); err != nil {
   278  		return thrift.PrependError("error reading list end: ", err)
   279  	}
   280  	return nil
   281  }
   282  
   283  func (p *ZResponse) Write(ctx context.Context, tp thrift.TProtocol) error {
   284  	if err := tp.WriteStructBegin(ctx, "ZResponse"); err != nil {
   285  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
   286  	}
   287  	if p != nil {
   288  		if err := p.writeField1(ctx, tp); err != nil {
   289  			return err
   290  		}
   291  		if err := p.writeField2(ctx, tp); err != nil {
   292  			return err
   293  		}
   294  		if err := p.writeField3(ctx, tp); err != nil {
   295  			return err
   296  		}
   297  	}
   298  	if err := tp.WriteFieldStop(ctx); err != nil {
   299  		return thrift.PrependError("write field stop error: ", err)
   300  	}
   301  	if err := tp.WriteStructEnd(ctx); err != nil {
   302  		return thrift.PrependError("write struct stop error: ", err)
   303  	}
   304  	return nil
   305  }
   306  
   307  func (p *ZResponse) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
   308  	if err := tp.WriteFieldBegin(ctx, "code", thrift.I32, 1); err != nil {
   309  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:code: ", p), err)
   310  	}
   311  	if err := tp.WriteI32(ctx, int32(p.Code)); err != nil {
   312  		return thrift.PrependError(fmt.Sprintf("%T.code (1) field write error: ", p), err)
   313  	}
   314  	if err := tp.WriteFieldEnd(ctx); err != nil {
   315  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:code: ", p), err)
   316  	}
   317  	return err
   318  }
   319  
   320  func (p *ZResponse) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
   321  	if err := tp.WriteFieldBegin(ctx, "msg", thrift.STRING, 2); err != nil {
   322  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:msg: ", p), err)
   323  	}
   324  	if err := tp.WriteString(ctx, string(p.Msg)); err != nil {
   325  		return thrift.PrependError(fmt.Sprintf("%T.msg (2) field write error: ", p), err)
   326  	}
   327  	if err := tp.WriteFieldEnd(ctx); err != nil {
   328  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:msg: ", p), err)
   329  	}
   330  	return err
   331  }
   332  
   333  func (p *ZResponse) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
   334  	if err := tp.WriteFieldBegin(ctx, "res", thrift.LIST, 3); err != nil {
   335  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:res: ", p), err)
   336  	}
   337  	if err := tp.WriteListBegin(ctx, thrift.STRUCT, len(p.Res)); err != nil {
   338  		return thrift.PrependError("error writing list begin: ", err)
   339  	}
   340  	for _, v := range p.Res {
   341  		if err := v.Write(ctx, tp); err != nil {
   342  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
   343  		}
   344  	}
   345  	if err := tp.WriteListEnd(ctx); err != nil {
   346  		return thrift.PrependError("error writing list end: ", err)
   347  	}
   348  	if err := tp.WriteFieldEnd(ctx); err != nil {
   349  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:res: ", p), err)
   350  	}
   351  	return err
   352  }
   353  
   354  func (p *ZResponse) String() string {
   355  	if p == nil {
   356  		return "<nil>"
   357  	}
   358  	return fmt.Sprintf("ZResponse(%+v)", *p)
   359  }
   360  
   361  type RedisProxy interface {
   362  	// Parameters:
   363  	//  - Echo
   364  	Ping(ctx context.Context, echo int32) (r int32, err error)
   365  	// Parameters:
   366  	//  - Echo
   367  	RedisProxyPing(ctx context.Context, echo int32) (r int32, err error)
   368  	// Parameters:
   369  	//  - AppId
   370  	//  - Key
   371  	//  - Value
   372  	GetSet(ctx context.Context, appid string, key string, value string) (r *Response, err error)
   373  	// Parameters:
   374  	//  - AppId
   375  	//  - Key
   376  	//  - Value
   377  	GetSetBytes(ctx context.Context, appid string, key string, value []byte) (r *BytesResponse, err error)
   378  	// Parameters:
   379  	//  - AppId
   380  	//  - Key
   381  	//  - Value
   382  	//  - TTL
   383  	Set(ctx context.Context, appid string, key string, value string, ttl int64) (r *Response, err error)
   384  	// Parameters:
   385  	//  - AppId
   386  	//  - Key
   387  	//  - Value
   388  	//  - TTL
   389  	SetBytes(ctx context.Context, appid string, key string, value []byte, ttl int64) (r *Response, err error)
   390  	// Parameters:
   391  	//  - AppId
   392  	//  - Key
   393  	//  - Value
   394  	//  - TTL
   395  	SetNX(ctx context.Context, appid string, key string, value string, ttl int64) (r *Response, err error)
   396  	// Parameters:
   397  	//  - AppId
   398  	//  - Key
   399  	//  - Value
   400  	//  - TTL
   401  	SetNXBytes(ctx context.Context, appid string, key string, value []byte, ttl int64) (r *Response, err error)
   402  	// Parameters:
   403  	//  - AppId
   404  	//  - Key
   405  	Get(ctx context.Context, appid string, key string) (r *Response, err error)
   406  	// Parameters:
   407  	//  - AppId
   408  	//  - Key
   409  	GetBytes(ctx context.Context, appid string, key string) (r *BytesResponse, err error)
   410  	// Parameters:
   411  	//  - AppId
   412  	//  - Reqs
   413  	MSet(ctx context.Context, appid string, reqs map[string]string) (r *Response, err error)
   414  	// Parameters:
   415  	//  - AppId
   416  	//  - Reqs
   417  	MSetBytes(ctx context.Context, appid string, reqs map[string][]byte) (r *Response, err error)
   418  	// Parameters:
   419  	//  - AppId
   420  	//  - Keys
   421  	MGet(ctx context.Context, appid string, keys []string) (r *MResponse, err error)
   422  	// Parameters:
   423  	//  - AppId
   424  	//  - Keys
   425  	MGetBytes(ctx context.Context, appid string, keys []string) (r *MBytesResponse, err error)
   426  	// Parameters:
   427  	//  - AppId
   428  	//  - Key
   429  	Del(ctx context.Context, appid string, key string) (r *IntResponse, err error)
   430  	// Parameters:
   431  	//  - AppId
   432  	//  - Keys
   433  	MDel(ctx context.Context, appid string, keys []string) (r *IntResponse, err error)
   434  	// Parameters:
   435  	//  - AppId
   436  	//  - Key
   437  	Keys(ctx context.Context, appid string, key string) (r *LResponse, err error)
   438  	// Parameters:
   439  	//  - AppId
   440  	//  - Key
   441  	//  - TTL
   442  	Expire(ctx context.Context, appid string, key string, ttl int64) (r *Response, err error)
   443  	// Parameters:
   444  	//  - AppId
   445  	//  - Key
   446  	TTL(ctx context.Context, appid string, key string) (r *IntResponse, err error)
   447  	// Parameters:
   448  	//  - AppId
   449  	//  - Key
   450  	Exists(ctx context.Context, appid string, key string) (r *Response, err error)
   451  	// Parameters:
   452  	//  - AppId
   453  	//  - Key
   454  	//  - Field
   455  	//  - Value
   456  	HSet(ctx context.Context, appid string, key string, field string, value string) (r *Response, err error)
   457  	// Parameters:
   458  	//  - AppId
   459  	//  - Key
   460  	//  - Field
   461  	//  - Value
   462  	HSetBytes(ctx context.Context, appid string, key string, field string, value []byte) (r *Response, err error)
   463  	// Parameters:
   464  	//  - AppId
   465  	//  - Key
   466  	//  - Field
   467  	//  - Value
   468  	HSetNX(ctx context.Context, appid string, key string, field string, value string) (r *Response, err error)
   469  	// Parameters:
   470  	//  - AppId
   471  	//  - Key
   472  	//  - Field
   473  	//  - Value
   474  	HSetNXBytes(ctx context.Context, appid string, key string, field string, value string) (r *Response, err error)
   475  	// Parameters:
   476  	//  - AppId
   477  	//  - Key
   478  	//  - Field
   479  	HGet(ctx context.Context, appid string, key string, field string) (r *Response, err error)
   480  	// Parameters:
   481  	//  - AppId
   482  	//  - Key
   483  	//  - Field
   484  	HGetBytes(ctx context.Context, appid string, key string, field string) (r *BytesResponse, err error)
   485  	// Parameters:
   486  	//  - AppId
   487  	//  - Key
   488  	//  - Fields
   489  	HMSet(ctx context.Context, appid string, key string, fields map[string]string) (r *Response, err error)
   490  	// Parameters:
   491  	//  - AppId
   492  	//  - Key
   493  	//  - Fields
   494  	HMSetBytes(ctx context.Context, appid string, key string, fields map[string][]byte) (r *Response, err error)
   495  	// Parameters:
   496  	//  - AppId
   497  	//  - Key
   498  	//  - Fields
   499  	HMGet(ctx context.Context, appid string, key string, fields []string) (r *MResponse, err error)
   500  	// Parameters:
   501  	//  - AppId
   502  	//  - Key
   503  	//  - Fields
   504  	HMGetBytes(ctx context.Context, appid string, key string, fields []string) (r *MBytesResponse, err error)
   505  	// Parameters:
   506  	//  - AppId
   507  	//  - Key
   508  	HGetAll(ctx context.Context, appid string, key string) (r *MResponse, err error)
   509  	// Parameters:
   510  	//  - AppId
   511  	//  - Key
   512  	//  - Field
   513  	HDel(ctx context.Context, appid string, key string, field string) (r *IntResponse, err error)
   514  	// Parameters:
   515  	//  - AppId
   516  	//  - Key
   517  	//  - Fields
   518  	MHDel(ctx context.Context, appid string, key string, fields []string) (r *IntResponse, err error)
   519  	// Parameters:
   520  	//  - AppId
   521  	//  - Key
   522  	HKeys(ctx context.Context, appid string, key string) (r *LResponse, err error)
   523  	// Parameters:
   524  	//  - AppId
   525  	//  - Key
   526  	HVals(ctx context.Context, appid string, key string) (r *LResponse, err error)
   527  	// Parameters:
   528  	//  - AppId
   529  	//  - Key
   530  	//  - Field
   531  	//  - Inrc
   532  	HIncrBy(ctx context.Context, appid string, key string, field string, inrc int64) (r *IntResponse, err error)
   533  	// Parameters:
   534  	//  - AppId
   535  	//  - Key
   536  	//  - Field
   537  	//  - Inrc
   538  	HIncrByFloat(ctx context.Context, appid string, key string, field string, inrc float64) (r *FloatResponse, err error)
   539  	// Parameters:
   540  	//  - AppId
   541  	//  - Key
   542  	//  - Field
   543  	HExists(ctx context.Context, appid string, key string, field string) (r *Response, err error)
   544  	// Parameters:
   545  	//  - AppId
   546  	//  - Key
   547  	//  - Member
   548  	ZAdd(ctx context.Context, appid string, key string, member *Z) (r *IntResponse, err error)
   549  	// Parameters:
   550  	//  - AppId
   551  	//  - Key
   552  	//  - Members
   553  	MZAdd(ctx context.Context, appid string, key string, members []*Z) (r *IntResponse, err error)
   554  	// Parameters:
   555  	//  - AppId
   556  	//  - Key
   557  	ZCard(ctx context.Context, appid string, key string) (r *IntResponse, err error)
   558  	// Parameters:
   559  	//  - AppId
   560  	//  - Key
   561  	//  - Min
   562  	//  - Max
   563  	ZCount(ctx context.Context, appid string, key string, min string, max string) (r *IntResponse, err error)
   564  	// Parameters:
   565  	//  - AppId
   566  	//  - Key
   567  	//  - Start
   568  	//  - Stop
   569  	ZRangeWithScores(ctx context.Context, appid string, key string, start int64, stop int64) (r *ZResponse, err error)
   570  	// Parameters:
   571  	//  - AppId
   572  	//  - Key
   573  	//  - Min
   574  	//  - Max
   575  	//  - Offset
   576  	//  - Count
   577  	ZRangeByScoreWithScores(ctx context.Context, appid string, key string, min string, max string, offset int64, count int64) (r *ZResponse, err error)
   578  	// Parameters:
   579  	//  - AppId
   580  	//  - Key
   581  	//  - Member
   582  	ZRem(ctx context.Context, appid string, key string, member string) (r *IntResponse, err error)
   583  	// Parameters:
   584  	//  - AppId
   585  	//  - Key
   586  	//  - Members
   587  	MZRem(ctx context.Context, appid string, key string, members []string) (r *IntResponse, err error)
   588  	// Parameters:
   589  	//  - AppId
   590  	//  - Key
   591  	//  - Start
   592  	//  - Stop
   593  	ZRemRangeByRank(ctx context.Context, appid string, key string, start int64, stop int64) (r *IntResponse, err error)
   594  	// Parameters:
   595  	//  - AppId
   596  	//  - Key
   597  	//  - Min
   598  	//  - Max
   599  	ZRemRangeByScore(ctx context.Context, appid string, key string, min string, max string) (r *IntResponse, err error)
   600  	// Parameters:
   601  	//  - AppId
   602  	//  - Key
   603  	//  - Increment
   604  	//  - Member
   605  	ZIncrBy(ctx context.Context, appid string, key string, increment float64, member string) (r *FloatResponse, err error)
   606  	// Parameters:
   607  	//  - AppId
   608  	//  - Key
   609  	//  - Member
   610  	ZScore(ctx context.Context, appid string, key string, member string) (r *FloatResponse, err error)
   611  	// Parameters:
   612  	//  - AppId
   613  	//  - Key
   614  	//  - Member
   615  	SAdd(ctx context.Context, appid string, key string, member string) (r *IntResponse, err error)
   616  	// Parameters:
   617  	//  - AppId
   618  	//  - Key
   619  	//  - Members
   620  	MSAdd(ctx context.Context, appid string, key string, members []string) (r *IntResponse, err error)
   621  	// Parameters:
   622  	//  - AppId
   623  	//  - Key
   624  	SCard(ctx context.Context, appid string, key string) (r *IntResponse, err error)
   625  	// Parameters:
   626  	//  - AppId
   627  	//  - Key
   628  	//  - Member
   629  	SIsMember(ctx context.Context, appid string, key string, member string) (r *Response, err error)
   630  	// Parameters:
   631  	//  - AppId
   632  	//  - Key
   633  	SMembers(ctx context.Context, appid string, key string) (r *LResponse, err error)
   634  	// Parameters:
   635  	//  - AppId
   636  	//  - Key
   637  	SRandMember(ctx context.Context, appid string, key string) (r *Response, err error)
   638  	// Parameters:
   639  	//  - AppId
   640  	//  - Key
   641  	//  - N
   642  	SRandMemberN(ctx context.Context, appid string, key string, n int64) (r *LResponse, err error)
   643  	// Parameters:
   644  	//  - AppId
   645  	//  - Key
   646  	//  - Member
   647  	SRem(ctx context.Context, appid string, key string, member string) (r *IntResponse, err error)
   648  	// Parameters:
   649  	//  - AppId
   650  	//  - Key
   651  	//  - Member
   652  	MSRem(ctx context.Context, appid string, key string, member []string) (r *IntResponse, err error)
   653  	// Parameters:
   654  	//  - AppId
   655  	//  - Key
   656  	//  - Value
   657  	LPush(ctx context.Context, appid string, key string, value string) (r *IntResponse, err error)
   658  	// Parameters:
   659  	//  - AppId
   660  	//  - Key
   661  	//  - Value
   662  	LPushByte(ctx context.Context, appid string, key string, value []byte) (r *IntResponse, err error)
   663  	// Parameters:
   664  	//  - AppId
   665  	//  - Key
   666  	//  - Value
   667  	RPush(ctx context.Context, appid string, key string, value string) (r *IntResponse, err error)
   668  	// Parameters:
   669  	//  - AppId
   670  	//  - Key
   671  	//  - Value
   672  	RPushByte(ctx context.Context, appid string, key string, value []byte) (r *IntResponse, err error)
   673  	// Parameters:
   674  	//  - AppId
   675  	//  - Key
   676  	//  - Value
   677  	MLPush(ctx context.Context, appid string, key string, value []string) (r *IntResponse, err error)
   678  	// Parameters:
   679  	//  - AppId
   680  	//  - Key
   681  	//  - Value
   682  	//  - TTL
   683  	MLPushWithTTL(ctx context.Context, appid string, key string, value []string, ttl int64) (r *IntResponse, err error)
   684  	// Parameters:
   685  	//  - AppId
   686  	//  - Key
   687  	//  - Value
   688  	//  - TTL
   689  	MLPushByteWithTTL(ctx context.Context, appid string, key string, value [][]byte, ttl int64) (r *IntResponse, err error)
   690  	// Parameters:
   691  	//  - AppId
   692  	//  - Key
   693  	//  - Value
   694  	//  - TTL
   695  	MRPushWithTTL(ctx context.Context, appid string, key string, value []string, ttl int64) (r *IntResponse, err error)
   696  	// Parameters:
   697  	//  - AppId
   698  	//  - Key
   699  	//  - Value
   700  	//  - TTL
   701  	MRPushByteWithTTL(ctx context.Context, appid string, key string, value [][]byte, ttl int64) (r *IntResponse, err error)
   702  	// Parameters:
   703  	//  - AppId
   704  	//  - Key
   705  	LPop(ctx context.Context, appid string, key string) (r *Response, err error)
   706  	// Parameters:
   707  	//  - AppId
   708  	//  - Key
   709  	LPopByte(ctx context.Context, appid string, key string) (r *BytesResponse, err error)
   710  	// Parameters:
   711  	//  - AppId
   712  	//  - Key
   713  	RPop(ctx context.Context, appid string, key string) (r *Response, err error)
   714  	// Parameters:
   715  	//  - AppId
   716  	//  - Key
   717  	RPopByte(ctx context.Context, appid string, key string) (r *BytesResponse, err error)
   718  	// Parameters:
   719  	//  - AppId
   720  	//  - Key
   721  	//  - Pivot
   722  	//  - Value
   723  	LInsertBefore(ctx context.Context, appid string, key string, pivot string, value string) (r *IntResponse, err error)
   724  	// Parameters:
   725  	//  - AppId
   726  	//  - Key
   727  	//  - Pivot
   728  	//  - Value
   729  	LInsertAfter(ctx context.Context, appid string, key string, pivot string, value string) (r *IntResponse, err error)
   730  	// Parameters:
   731  	//  - AppId
   732  	//  - Key
   733  	LLen(ctx context.Context, appid string, key string) (r *IntResponse, err error)
   734  	// Parameters:
   735  	//  - AppId
   736  	//  - Keys
   737  	MLLen(ctx context.Context, appid string, keys []string) (r *MIntResponse, err error)
   738  	// Parameters:
   739  	//  - AppId
   740  	//  - Key
   741  	//  - Index
   742  	//  - Value
   743  	LSet(ctx context.Context, appid string, key string, index int64, value string) (r *Response, err error)
   744  	// Parameters:
   745  	//  - AppId
   746  	//  - Key
   747  	//  - Index
   748  	LIndex(ctx context.Context, appid string, key string, index int64) (r *Response, err error)
   749  	// Parameters:
   750  	//  - AppId
   751  	//  - Key
   752  	//  - Start
   753  	//  - Stop
   754  	LRange(ctx context.Context, appid string, key string, start int64, stop int64) (r *LResponse, err error)
   755  	// Parameters:
   756  	//  - AppId
   757  	//  - Key
   758  	//  - Start
   759  	//  - Stop
   760  	LTrim(ctx context.Context, appid string, key string, start int64, stop int64) (r *Response, err error)
   761  	// Parameters:
   762  	//  - AppId
   763  	ClusterNodes(ctx context.Context, appid string) (r *Response, err error)
   764  	// Parameters:
   765  	//  - AppId
   766  	ClusterInfo(ctx context.Context, appid string) (r *Response, err error)
   767  	// Parameters:
   768  	//  - AppId
   769  	//  - Sections
   770  	Info(ctx context.Context, appid string, sections []string) (r *MResponse, err error)
   771  	// Parameters:
   772  	//  - AppId
   773  	//  - Addr
   774  	//  - Sections
   775  	NodeInfo(ctx context.Context, appid string, addr string, sections []string) (r *Response, err error)
   776  }
   777  
   778  type RedisProxyProcessor struct {
   779  	processorMap map[string]thrift.TProcessorFunction
   780  	handler      RedisProxy
   781  }
   782  
   783  func (p *RedisProxyProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
   784  	p.processorMap[key] = processor
   785  }
   786  
   787  func (p *RedisProxyProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
   788  	processor, ok = p.processorMap[key]
   789  	return processor, ok
   790  }
   791  
   792  func (p *RedisProxyProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
   793  	return p.processorMap
   794  }
   795  
   796  func NewRedisProxyProcessor(handler RedisProxy) *RedisProxyProcessor {
   797  
   798  	self177 := &RedisProxyProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
   799  	self177.processorMap["Ping"] = &processorPing{
   800  		processorBase: processorBase{"Ping"},
   801  		handler:       handler}
   802  	self177.processorMap["redis_proxy_ping"] = &processorRedisProxyPing{
   803  		processorBase: processorBase{"redis_proxy_ping"},
   804  		handler:       handler}
   805  	self177.processorMap["GetSet"] = &processorGetSet{
   806  		processorBase: processorBase{"GetSet"},
   807  		handler:       handler}
   808  	self177.processorMap["GetSetBytes"] = &processorGetSetBytes{
   809  		processorBase: processorBase{"GetSetBytes"},
   810  		handler:       handler}
   811  	self177.processorMap["Set"] = &processorSet{
   812  		processorBase: processorBase{"Set"},
   813  		handler:       handler}
   814  	self177.processorMap["SetBytes"] = &processorSetBytes{
   815  		processorBase: processorBase{"SetBytes"},
   816  		handler:       handler}
   817  	self177.processorMap["SetNX"] = &processorSetNX{
   818  		processorBase: processorBase{"SetNX"},
   819  		handler:       handler}
   820  	self177.processorMap["SetNXBytes"] = &processorSetNXBytes{
   821  		processorBase: processorBase{"SetNXBytes"},
   822  		handler:       handler}
   823  	self177.processorMap["Get"] = &processorGet{
   824  		processorBase: processorBase{"Get"},
   825  		handler:       handler}
   826  	self177.processorMap["GetBytes"] = &processorGetBytes{
   827  		processorBase: processorBase{"GetBytes"},
   828  		handler:       handler}
   829  	self177.processorMap["MSet"] = &processorMSet{
   830  		processorBase: processorBase{"MSet"},
   831  		handler:       handler}
   832  	self177.processorMap["MSetBytes"] = &processorMSetBytes{
   833  		processorBase: processorBase{"MSetBytes"},
   834  		handler:       handler}
   835  	self177.processorMap["MGet"] = &processorMGet{
   836  		processorBase: processorBase{"MGet"},
   837  		handler:       handler}
   838  	self177.processorMap["MGetBytes"] = &processorMGetBytes{
   839  		processorBase: processorBase{"MGetBytes"},
   840  		handler:       handler}
   841  	self177.processorMap["Del"] = &processorDel{
   842  		processorBase: processorBase{"Del"},
   843  		handler:       handler}
   844  	self177.processorMap["MDel"] = &processorMDel{
   845  		processorBase: processorBase{"MDel"},
   846  		handler:       handler}
   847  	self177.processorMap["Keys"] = &processorKeys{
   848  		processorBase: processorBase{"Keys"},
   849  		handler:       handler}
   850  	self177.processorMap["Expire"] = &processorExpire{
   851  		processorBase: processorBase{"Expire"},
   852  		handler:       handler}
   853  	self177.processorMap["TTL"] = &processorTTL{
   854  		processorBase: processorBase{"TTL"},
   855  		handler:       handler}
   856  	self177.processorMap["Exists"] = &processorExists{
   857  		processorBase: processorBase{"Exists"},
   858  		handler:       handler}
   859  	self177.processorMap["HSet"] = &processorHSet{
   860  		processorBase: processorBase{"HSet"},
   861  		handler:       handler}
   862  	self177.processorMap["HSetBytes"] = &processorHSetBytes{
   863  		processorBase: processorBase{"HSetBytes"},
   864  		handler:       handler}
   865  	self177.processorMap["HSetNX"] = &processorHSetNX{
   866  		processorBase: processorBase{"HSetNX"},
   867  		handler:       handler}
   868  	self177.processorMap["HSetNXBytes"] = &processorHSetNXBytes{
   869  		processorBase: processorBase{"HSetNXBytes"},
   870  		handler:       handler}
   871  	self177.processorMap["HGet"] = &processorHGet{
   872  		processorBase: processorBase{"HGet"},
   873  		handler:       handler}
   874  	self177.processorMap["HGetBytes"] = &processorHGetBytes{
   875  		processorBase: processorBase{"HGetBytes"},
   876  		handler:       handler}
   877  	self177.processorMap["HMSet"] = &processorHMSet{
   878  		processorBase: processorBase{"HMSet"},
   879  		handler:       handler}
   880  	self177.processorMap["HMSetBytes"] = &processorHMSetBytes{
   881  		processorBase: processorBase{"HMSetBytes"},
   882  		handler:       handler}
   883  	self177.processorMap["HMGet"] = &processorHMGet{
   884  		processorBase: processorBase{"HMGet"},
   885  		handler:       handler}
   886  	self177.processorMap["HMGetBytes"] = &processorHMGetBytes{
   887  		processorBase: processorBase{"HMGetBytes"},
   888  		handler:       handler}
   889  	self177.processorMap["HGetAll"] = &processorHGetAll{
   890  		processorBase: processorBase{"HGetAll"},
   891  		handler:       handler}
   892  	self177.processorMap["HDel"] = &processorHDel{
   893  		processorBase: processorBase{"HDel"},
   894  		handler:       handler}
   895  	self177.processorMap["MHDel"] = &processorMHDel{
   896  		processorBase: processorBase{"MHDel"},
   897  		handler:       handler}
   898  	self177.processorMap["HKeys"] = &processorHKeys{
   899  		processorBase: processorBase{"HKeys"},
   900  		handler:       handler}
   901  	self177.processorMap["HVals"] = &processorHVals{
   902  		processorBase: processorBase{"HVals"},
   903  		handler:       handler}
   904  	self177.processorMap["HIncrBy"] = &processorHIncrBy{
   905  		processorBase: processorBase{"HIncrBy"},
   906  		handler:       handler}
   907  	self177.processorMap["HIncrByFloat"] = &processorHIncrByFloat{
   908  		processorBase: processorBase{"HIncrByFloat"},
   909  		handler:       handler}
   910  	self177.processorMap["HExists"] = &processorHExists{
   911  		processorBase: processorBase{"HExists"},
   912  		handler:       handler}
   913  	self177.processorMap["ZAdd"] = &processorZAdd{
   914  		processorBase: processorBase{"ZAdd"},
   915  		handler:       handler}
   916  	self177.processorMap["MZAdd"] = &processorMZAdd{
   917  		processorBase: processorBase{"MZAdd"},
   918  		handler:       handler}
   919  	self177.processorMap["ZCard"] = &processorZCard{
   920  		processorBase: processorBase{"ZCard"},
   921  		handler:       handler}
   922  	self177.processorMap["ZCount"] = &processorZCount{
   923  		processorBase: processorBase{"ZCount"},
   924  		handler:       handler}
   925  	self177.processorMap["ZRangeWithScores"] = &processorZRangeWithScores{
   926  		processorBase: processorBase{"ZRangeWithScores"},
   927  		handler:       handler}
   928  	self177.processorMap["ZRangeByScoreWithScores"] = &processorZRangeByScoreWithScores{
   929  		processorBase: processorBase{"ZRangeByScoreWithScores"},
   930  		handler:       handler}
   931  	self177.processorMap["ZRem"] = &processorZRem{
   932  		processorBase: processorBase{"ZRem"},
   933  		handler:       handler}
   934  	self177.processorMap["MZRem"] = &processorMZRem{
   935  		processorBase: processorBase{"MZRem"},
   936  		handler:       handler}
   937  	self177.processorMap["ZRemRangeByRank"] = &processorZRemRangeByRank{
   938  		processorBase: processorBase{"ZRemRangeByRank"},
   939  		handler:       handler}
   940  	self177.processorMap["ZRemRangeByScore"] = &processorZRemRangeByScore{
   941  		processorBase: processorBase{"ZRemRangeByScore"},
   942  		handler:       handler}
   943  	self177.processorMap["ZIncrBy"] = &processorZIncrBy{
   944  		processorBase: processorBase{"ZIncrBy"},
   945  		handler:       handler}
   946  	self177.processorMap["ZScore"] = &processorZScore{
   947  		processorBase: processorBase{"ZScore"},
   948  		handler:       handler}
   949  	self177.processorMap["SAdd"] = &processorSAdd{
   950  		processorBase: processorBase{"HGet"},
   951  		handler:       handler}
   952  	self177.processorMap["MSAdd"] = &processorMSAdd{
   953  		processorBase: processorBase{"MSAdd"},
   954  		handler:       handler}
   955  	self177.processorMap["SCard"] = &processorSCard{
   956  		processorBase: processorBase{"SCard"},
   957  		handler:       handler}
   958  	self177.processorMap["SIsMember"] = &processorSIsMember{
   959  		processorBase: processorBase{"SIsMember"},
   960  		handler:       handler}
   961  	self177.processorMap["SMembers"] = &processorSMembers{
   962  		processorBase: processorBase{"SMembers"},
   963  		handler:       handler}
   964  	self177.processorMap["SRandMember"] = &processorSRandMember{
   965  		processorBase: processorBase{"SRandMember"},
   966  		handler:       handler}
   967  	self177.processorMap["SRandMemberN"] = &processorSRandMemberN{
   968  		processorBase: processorBase{"SRandMemberN"},
   969  		handler:       handler}
   970  	self177.processorMap["SRem"] = &processorSRem{
   971  		processorBase: processorBase{"SRem"},
   972  		handler:       handler}
   973  	self177.processorMap["MSRem"] = &processorMSRem{
   974  		processorBase: processorBase{"MSRem"},
   975  		handler:       handler}
   976  	self177.processorMap["LPush"] = &processorLPush{
   977  		processorBase: processorBase{"LPush"},
   978  		handler:       handler}
   979  	self177.processorMap["LPushByte"] = &processorLPushByte{
   980  		processorBase: processorBase{"LPushByte"},
   981  		handler:       handler}
   982  	self177.processorMap["RPush"] = &processorRPush{
   983  		processorBase: processorBase{"RPush"},
   984  		handler:       handler}
   985  	self177.processorMap["RPushByte"] = &processorRPushByte{
   986  		processorBase: processorBase{"RPushByte"},
   987  		handler:       handler}
   988  	self177.processorMap["MLPush"] = &processorMLPush{
   989  		processorBase: processorBase{"MLPush"},
   990  		handler:       handler}
   991  	self177.processorMap["MLPushWithTTL"] = &processorMLPushWithTTL{
   992  		processorBase: processorBase{"MLPushWithTTL"},
   993  		handler:       handler}
   994  	self177.processorMap["MLPushByteWithTTL"] = &processorMLPushByteWithTTL{
   995  		processorBase: processorBase{"MLPushByteWithTTL"},
   996  		handler:       handler}
   997  	self177.processorMap["MRPushWithTTL"] = &processorMRPushWithTTL{
   998  		processorBase: processorBase{"MRPushWithTTL"},
   999  		handler:       handler}
  1000  	self177.processorMap["MRPushByteWithTTL"] = &processorMRPushByteWithTTL{
  1001  		processorBase: processorBase{"MRPushByteWithTTL"},
  1002  		handler:       handler}
  1003  	self177.processorMap["LPop"] = &processorLPop{
  1004  		processorBase: processorBase{"LPop"},
  1005  		handler:       handler}
  1006  	self177.processorMap["LPopByte"] = &processorLPopByte{
  1007  		processorBase: processorBase{"LPopByte"},
  1008  		handler:       handler}
  1009  	self177.processorMap["RPop"] = &processorRPop{
  1010  		processorBase: processorBase{"RPop"},
  1011  		handler:       handler}
  1012  	self177.processorMap["RPopByte"] = &processorRPopByte{
  1013  		processorBase: processorBase{"RPopByte"},
  1014  		handler:       handler}
  1015  	self177.processorMap["LInsertBefore"] = &processorLInsertBefore{
  1016  		processorBase: processorBase{"LInsertBefore"},
  1017  		handler:       handler}
  1018  	self177.processorMap["LInsertAfter"] = &processorLInsertAfter{
  1019  		processorBase: processorBase{"LInsertAfter"},
  1020  		handler:       handler}
  1021  	self177.processorMap["LLen"] = &processorLLen{
  1022  		processorBase: processorBase{"LLen"},
  1023  		handler:       handler}
  1024  	self177.processorMap["MLLen"] = &processorMLLen{
  1025  		processorBase: processorBase{"MLLen"},
  1026  		handler:       handler}
  1027  	self177.processorMap["LSet"] = &processorLSet{
  1028  		processorBase: processorBase{"LSet"},
  1029  		handler:       handler}
  1030  	self177.processorMap["LIndex"] = &processorLIndex{
  1031  		processorBase: processorBase{"LIndex"},
  1032  		handler:       handler}
  1033  	self177.processorMap["LRange"] = &processorLRange{
  1034  		processorBase: processorBase{"LRange"},
  1035  		handler:       handler}
  1036  	self177.processorMap["LTrim"] = &processorLTrim{
  1037  		processorBase: processorBase{"LTrim"},
  1038  		handler:       handler}
  1039  	self177.processorMap["ClusterNodes"] = &processorClusterNodes{
  1040  		processorBase: processorBase{"ClusterNodes"},
  1041  		handler:       handler}
  1042  	self177.processorMap["ClusterInfo"] = &processorClusterInfo{
  1043  		processorBase: processorBase{"ClusterInfo"},
  1044  		handler:       handler}
  1045  	self177.processorMap["Info"] = &processorInfo{
  1046  		processorBase: processorBase{"Info"},
  1047  		handler:       handler}
  1048  	self177.processorMap["NodeInfo"] = &processorNodeInfo{
  1049  		processorBase: processorBase{"NodeInfo"},
  1050  		handler:       handler}
  1051  	return self177
  1052  }
  1053  
  1054  func (p *RedisProxyProcessor) Process(ctx context.Context, in, out thrift.TProtocol) (success bool, err thrift.TException) {
  1055  	name, _, seqId, err2 := in.ReadMessageBegin(ctx)
  1056  	if err2 != nil {
  1057  		return false, thrift.WrapTException(err2)
  1058  	}
  1059  	if processor, ok := p.GetProcessorFunction(name); ok {
  1060  		return processor.Process(ctx, seqId, in, out)
  1061  	}
  1062  	in.Skip(ctx, thrift.STRUCT)
  1063  	in.ReadMessageEnd(ctx)
  1064  	x178 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
  1065  	in.WriteMessageBegin(ctx, name, thrift.EXCEPTION, seqId)
  1066  	x178.Write(ctx, in)
  1067  	in.WriteMessageEnd(ctx)
  1068  	in.Flush(ctx)
  1069  	return false, x178
  1070  
  1071  }
  1072  
  1073  // HELPER FUNCTIONS AND STRUCTURES
  1074  
  1075  // Attributes:
  1076  //  - Echo
  1077  type PingArgs struct {
  1078  	Echo int32 `thrift:"echo,1" db:"echo" json:"echo"`
  1079  }
  1080  
  1081  func NewPingArgs() *PingArgs {
  1082  	return &PingArgs{}
  1083  }
  1084  
  1085  func (p *PingArgs) GetEcho() int32 {
  1086  	return p.Echo
  1087  }
  1088  
  1089  func (p *PingArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  1090  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1091  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1092  	}
  1093  
  1094  	for {
  1095  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1096  		if err != nil {
  1097  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1098  		}
  1099  		if fieldTypeId == thrift.STOP {
  1100  			break
  1101  		}
  1102  		switch fieldId {
  1103  		case 1:
  1104  			if fieldTypeId == thrift.I32 {
  1105  				if err := p.ReadField1(ctx, tp); err != nil {
  1106  					return err
  1107  				}
  1108  			} else {
  1109  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1110  					return err
  1111  				}
  1112  			}
  1113  		default:
  1114  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1115  				return err
  1116  			}
  1117  		}
  1118  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1119  			return err
  1120  		}
  1121  	}
  1122  	if err := tp.ReadStructEnd(ctx); err != nil {
  1123  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1124  	}
  1125  	return nil
  1126  }
  1127  
  1128  func (p *PingArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  1129  	if v, err := tp.ReadI32(ctx); err != nil {
  1130  		return thrift.PrependError("error reading field 1: ", err)
  1131  	} else {
  1132  		p.Echo = v
  1133  	}
  1134  	return nil
  1135  }
  1136  
  1137  func (p *PingArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  1138  	if err := tp.WriteStructBegin(ctx, "Ping_args"); err != nil {
  1139  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1140  	}
  1141  	if p != nil {
  1142  		if err := p.writeField1(ctx, tp); err != nil {
  1143  			return err
  1144  		}
  1145  	}
  1146  	if err := tp.WriteFieldStop(ctx); err != nil {
  1147  		return thrift.PrependError("write field stop error: ", err)
  1148  	}
  1149  	if err := tp.WriteStructEnd(ctx); err != nil {
  1150  		return thrift.PrependError("write struct stop error: ", err)
  1151  	}
  1152  	return nil
  1153  }
  1154  
  1155  func (p *PingArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  1156  	if err := tp.WriteFieldBegin(ctx, "echo", thrift.I32, 1); err != nil {
  1157  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:echo: ", p), err)
  1158  	}
  1159  	if err := tp.WriteI32(ctx, int32(p.Echo)); err != nil {
  1160  		return thrift.PrependError(fmt.Sprintf("%T.echo (1) field write error: ", p), err)
  1161  	}
  1162  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1163  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:echo: ", p), err)
  1164  	}
  1165  	return err
  1166  }
  1167  
  1168  func (p *PingArgs) String() string {
  1169  	if p == nil {
  1170  		return "<nil>"
  1171  	}
  1172  	return fmt.Sprintf("PingArgs(%+v)", *p)
  1173  }
  1174  
  1175  // Attributes:
  1176  //  - Success
  1177  type PingResult struct {
  1178  	Success *int32 `thrift:"success,0" db:"success" json:"success,omitempty"`
  1179  }
  1180  
  1181  func NewPingResult() *PingResult {
  1182  	return &PingResult{}
  1183  }
  1184  
  1185  var PingResult_Success_DEFAULT int32
  1186  
  1187  func (p *PingResult) GetSuccess() int32 {
  1188  	if !p.IsSetSuccess() {
  1189  		return PingResult_Success_DEFAULT
  1190  	}
  1191  	return *p.Success
  1192  }
  1193  func (p *PingResult) IsSetSuccess() bool {
  1194  	return p.Success != nil
  1195  }
  1196  
  1197  func (p *PingResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  1198  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1199  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1200  	}
  1201  
  1202  	for {
  1203  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1204  		if err != nil {
  1205  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1206  		}
  1207  		if fieldTypeId == thrift.STOP {
  1208  			break
  1209  		}
  1210  		switch fieldId {
  1211  		case 0:
  1212  			if fieldTypeId == thrift.I32 {
  1213  				if err := p.ReadField0(ctx, tp); err != nil {
  1214  					return err
  1215  				}
  1216  			} else {
  1217  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1218  					return err
  1219  				}
  1220  			}
  1221  		default:
  1222  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1223  				return err
  1224  			}
  1225  		}
  1226  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1227  			return err
  1228  		}
  1229  	}
  1230  	if err := tp.ReadStructEnd(ctx); err != nil {
  1231  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1232  	}
  1233  	return nil
  1234  }
  1235  
  1236  func (p *PingResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  1237  	if v, err := tp.ReadI32(ctx); err != nil {
  1238  		return thrift.PrependError("error reading field 0: ", err)
  1239  	} else {
  1240  		p.Success = &v
  1241  	}
  1242  	return nil
  1243  }
  1244  
  1245  func (p *PingResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  1246  	if err := tp.WriteStructBegin(ctx, "Ping_result"); err != nil {
  1247  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1248  	}
  1249  	if p != nil {
  1250  		if err := p.writeField0(ctx, tp); err != nil {
  1251  			return err
  1252  		}
  1253  	}
  1254  	if err := tp.WriteFieldStop(ctx); err != nil {
  1255  		return thrift.PrependError("write field stop error: ", err)
  1256  	}
  1257  	if err := tp.WriteStructEnd(ctx); err != nil {
  1258  		return thrift.PrependError("write struct stop error: ", err)
  1259  	}
  1260  	return nil
  1261  }
  1262  
  1263  func (p *PingResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  1264  	if p.IsSetSuccess() {
  1265  		if err := tp.WriteFieldBegin(ctx, "success", thrift.I32, 0); err != nil {
  1266  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  1267  		}
  1268  		if err := tp.WriteI32(ctx, int32(*p.Success)); err != nil {
  1269  			return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err)
  1270  		}
  1271  		if err := tp.WriteFieldEnd(ctx); err != nil {
  1272  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  1273  		}
  1274  	}
  1275  	return err
  1276  }
  1277  
  1278  func (p *PingResult) String() string {
  1279  	if p == nil {
  1280  		return "<nil>"
  1281  	}
  1282  	return fmt.Sprintf("PingResult(%+v)", *p)
  1283  }
  1284  
  1285  // Attributes:
  1286  //  - Echo
  1287  type RedisProxyPingArgs struct {
  1288  	Echo int32 `thrift:"echo,1" db:"echo" json:"echo"`
  1289  }
  1290  
  1291  func NewRedisProxyPingArgs() *RedisProxyPingArgs {
  1292  	return &RedisProxyPingArgs{}
  1293  }
  1294  
  1295  func (p *RedisProxyPingArgs) GetEcho() int32 {
  1296  	return p.Echo
  1297  }
  1298  
  1299  func (p *RedisProxyPingArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  1300  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1301  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1302  	}
  1303  
  1304  	for {
  1305  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1306  		if err != nil {
  1307  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1308  		}
  1309  		if fieldTypeId == thrift.STOP {
  1310  			break
  1311  		}
  1312  		switch fieldId {
  1313  		case 1:
  1314  			if fieldTypeId == thrift.I32 {
  1315  				if err := p.ReadField1(ctx, tp); err != nil {
  1316  					return err
  1317  				}
  1318  			} else {
  1319  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1320  					return err
  1321  				}
  1322  			}
  1323  		default:
  1324  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1325  				return err
  1326  			}
  1327  		}
  1328  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1329  			return err
  1330  		}
  1331  	}
  1332  	if err := tp.ReadStructEnd(ctx); err != nil {
  1333  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1334  	}
  1335  	return nil
  1336  }
  1337  
  1338  func (p *RedisProxyPingArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  1339  	if v, err := tp.ReadI32(ctx); err != nil {
  1340  		return thrift.PrependError("error reading field 1: ", err)
  1341  	} else {
  1342  		p.Echo = v
  1343  	}
  1344  	return nil
  1345  }
  1346  
  1347  func (p *RedisProxyPingArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  1348  	if err := tp.WriteStructBegin(ctx, "redis_proxy_ping_args"); err != nil {
  1349  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1350  	}
  1351  	if p != nil {
  1352  		if err := p.writeField1(ctx, tp); err != nil {
  1353  			return err
  1354  		}
  1355  	}
  1356  	if err := tp.WriteFieldStop(ctx); err != nil {
  1357  		return thrift.PrependError("write field stop error: ", err)
  1358  	}
  1359  	if err := tp.WriteStructEnd(ctx); err != nil {
  1360  		return thrift.PrependError("write struct stop error: ", err)
  1361  	}
  1362  	return nil
  1363  }
  1364  
  1365  func (p *RedisProxyPingArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  1366  	if err := tp.WriteFieldBegin(ctx, "echo", thrift.I32, 1); err != nil {
  1367  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:echo: ", p), err)
  1368  	}
  1369  	if err := tp.WriteI32(ctx, int32(p.Echo)); err != nil {
  1370  		return thrift.PrependError(fmt.Sprintf("%T.echo (1) field write error: ", p), err)
  1371  	}
  1372  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1373  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:echo: ", p), err)
  1374  	}
  1375  	return err
  1376  }
  1377  
  1378  func (p *RedisProxyPingArgs) String() string {
  1379  	if p == nil {
  1380  		return "<nil>"
  1381  	}
  1382  	return fmt.Sprintf("RedisProxyPingArgs(%+v)", *p)
  1383  }
  1384  
  1385  // Attributes:
  1386  //  - Success
  1387  type RedisProxyPingResult struct {
  1388  	Success *int32 `thrift:"success,0" db:"success" json:"success,omitempty"`
  1389  }
  1390  
  1391  func NewRedisProxyPingResult() *RedisProxyPingResult {
  1392  	return &RedisProxyPingResult{}
  1393  }
  1394  
  1395  func (p *RedisProxyPingResult) GetSuccess() int32 {
  1396  	if !p.IsSetSuccess() {
  1397  		return PingResult_Success_DEFAULT
  1398  	}
  1399  	return *p.Success
  1400  }
  1401  func (p *RedisProxyPingResult) IsSetSuccess() bool {
  1402  	return p.Success != nil
  1403  }
  1404  
  1405  func (p *RedisProxyPingResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  1406  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1407  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1408  	}
  1409  
  1410  	for {
  1411  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1412  		if err != nil {
  1413  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1414  		}
  1415  		if fieldTypeId == thrift.STOP {
  1416  			break
  1417  		}
  1418  		switch fieldId {
  1419  		case 0:
  1420  			if fieldTypeId == thrift.I32 {
  1421  				if err := p.ReadField0(ctx, tp); err != nil {
  1422  					return err
  1423  				}
  1424  			} else {
  1425  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1426  					return err
  1427  				}
  1428  			}
  1429  		default:
  1430  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1431  				return err
  1432  			}
  1433  		}
  1434  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1435  			return err
  1436  		}
  1437  	}
  1438  	if err := tp.ReadStructEnd(ctx); err != nil {
  1439  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1440  	}
  1441  	return nil
  1442  }
  1443  
  1444  func (p *RedisProxyPingResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  1445  	if v, err := tp.ReadI32(ctx); err != nil {
  1446  		return thrift.PrependError("error reading field 0: ", err)
  1447  	} else {
  1448  		p.Success = &v
  1449  	}
  1450  	return nil
  1451  }
  1452  
  1453  func (p *RedisProxyPingResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  1454  	if err := tp.WriteStructBegin(ctx, "redis_proxy_ping_result"); err != nil {
  1455  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1456  	}
  1457  	if p != nil {
  1458  		if err := p.writeField0(ctx, tp); err != nil {
  1459  			return err
  1460  		}
  1461  	}
  1462  	if err := tp.WriteFieldStop(ctx); err != nil {
  1463  		return thrift.PrependError("write field stop error: ", err)
  1464  	}
  1465  	if err := tp.WriteStructEnd(ctx); err != nil {
  1466  		return thrift.PrependError("write struct stop error: ", err)
  1467  	}
  1468  	return nil
  1469  }
  1470  
  1471  func (p *RedisProxyPingResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  1472  	if p.IsSetSuccess() {
  1473  		if err := tp.WriteFieldBegin(ctx, "success", thrift.I32, 0); err != nil {
  1474  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  1475  		}
  1476  		if err := tp.WriteI32(ctx, int32(*p.Success)); err != nil {
  1477  			return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err)
  1478  		}
  1479  		if err := tp.WriteFieldEnd(ctx); err != nil {
  1480  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  1481  		}
  1482  	}
  1483  	return err
  1484  }
  1485  
  1486  func (p *RedisProxyPingResult) String() string {
  1487  	if p == nil {
  1488  		return "<nil>"
  1489  	}
  1490  	return fmt.Sprintf("RedisProxyPingResult(%+v)", *p)
  1491  }
  1492  
  1493  // Attributes:
  1494  //  - Appid
  1495  //  - Key
  1496  //  - Value
  1497  type GetSetArgs struct {
  1498  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  1499  	Key   string `thrift:"key,2" db:"key" json:"key"`
  1500  	Value string `thrift:"value,3" db:"value" json:"value"`
  1501  }
  1502  
  1503  func NewGetSetArgs() *GetSetArgs {
  1504  	return &GetSetArgs{}
  1505  }
  1506  
  1507  func (p *GetSetArgs) GetAppid() string {
  1508  	return p.Appid
  1509  }
  1510  
  1511  func (p *GetSetArgs) GetKey() string {
  1512  	return p.Key
  1513  }
  1514  
  1515  func (p *GetSetArgs) GetValue() string {
  1516  	return p.Value
  1517  }
  1518  
  1519  func (p *GetSetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  1520  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1521  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1522  	}
  1523  
  1524  	for {
  1525  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1526  		if err != nil {
  1527  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1528  		}
  1529  		if fieldTypeId == thrift.STOP {
  1530  			break
  1531  		}
  1532  		switch fieldId {
  1533  		case 1:
  1534  			if fieldTypeId == thrift.STRING {
  1535  				if err := p.ReadField1(ctx, tp); err != nil {
  1536  					return err
  1537  				}
  1538  			} else {
  1539  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1540  					return err
  1541  				}
  1542  			}
  1543  		case 2:
  1544  			if fieldTypeId == thrift.STRING {
  1545  				if err := p.ReadField2(ctx, tp); err != nil {
  1546  					return err
  1547  				}
  1548  			} else {
  1549  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1550  					return err
  1551  				}
  1552  			}
  1553  		case 3:
  1554  			if fieldTypeId == thrift.STRING {
  1555  				if err := p.ReadField3(ctx, tp); err != nil {
  1556  					return err
  1557  				}
  1558  			} else {
  1559  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1560  					return err
  1561  				}
  1562  			}
  1563  		default:
  1564  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1565  				return err
  1566  			}
  1567  		}
  1568  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1569  			return err
  1570  		}
  1571  	}
  1572  	if err := tp.ReadStructEnd(ctx); err != nil {
  1573  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1574  	}
  1575  	return nil
  1576  }
  1577  
  1578  func (p *GetSetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  1579  	if v, err := tp.ReadString(ctx); err != nil {
  1580  		return thrift.PrependError("error reading field 1: ", err)
  1581  	} else {
  1582  		p.Appid = v
  1583  	}
  1584  	return nil
  1585  }
  1586  
  1587  func (p *GetSetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  1588  	if v, err := tp.ReadString(ctx); err != nil {
  1589  		return thrift.PrependError("error reading field 2: ", err)
  1590  	} else {
  1591  		p.Key = v
  1592  	}
  1593  	return nil
  1594  }
  1595  
  1596  func (p *GetSetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  1597  	if v, err := tp.ReadString(ctx); err != nil {
  1598  		return thrift.PrependError("error reading field 3: ", err)
  1599  	} else {
  1600  		p.Value = v
  1601  	}
  1602  	return nil
  1603  }
  1604  
  1605  func (p *GetSetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  1606  	if err := tp.WriteStructBegin(ctx, "GetSet_args"); err != nil {
  1607  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1608  	}
  1609  	if p != nil {
  1610  		if err := p.writeField1(ctx, tp); err != nil {
  1611  			return err
  1612  		}
  1613  		if err := p.writeField2(ctx, tp); err != nil {
  1614  			return err
  1615  		}
  1616  		if err := p.writeField3(ctx, tp); err != nil {
  1617  			return err
  1618  		}
  1619  	}
  1620  	if err := tp.WriteFieldStop(ctx); err != nil {
  1621  		return thrift.PrependError("write field stop error: ", err)
  1622  	}
  1623  	if err := tp.WriteStructEnd(ctx); err != nil {
  1624  		return thrift.PrependError("write struct stop error: ", err)
  1625  	}
  1626  	return nil
  1627  }
  1628  
  1629  func (p *GetSetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  1630  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  1631  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  1632  	}
  1633  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  1634  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  1635  	}
  1636  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1637  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  1638  	}
  1639  	return err
  1640  }
  1641  
  1642  func (p *GetSetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  1643  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  1644  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  1645  	}
  1646  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  1647  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  1648  	}
  1649  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1650  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  1651  	}
  1652  	return err
  1653  }
  1654  
  1655  func (p *GetSetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  1656  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  1657  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  1658  	}
  1659  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  1660  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  1661  	}
  1662  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1663  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  1664  	}
  1665  	return err
  1666  }
  1667  
  1668  func (p *GetSetArgs) String() string {
  1669  	if p == nil {
  1670  		return "<nil>"
  1671  	}
  1672  	return fmt.Sprintf("GetSetArgs(%+v)", *p)
  1673  }
  1674  
  1675  // Attributes:
  1676  //  - Success
  1677  type GetSetResult struct {
  1678  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  1679  }
  1680  
  1681  func NewRedisProxyGetSetResult() *GetSetResult {
  1682  	return &GetSetResult{}
  1683  }
  1684  
  1685  var RedisProxyGetSetResult_Success_DEFAULT *Response
  1686  
  1687  func (p *GetSetResult) GetSuccess() *Response {
  1688  	if !p.IsSetSuccess() {
  1689  		return RedisProxyGetSetResult_Success_DEFAULT
  1690  	}
  1691  	return p.Success
  1692  }
  1693  func (p *GetSetResult) IsSetSuccess() bool {
  1694  	return p.Success != nil
  1695  }
  1696  
  1697  func (p *GetSetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  1698  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1699  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1700  	}
  1701  
  1702  	for {
  1703  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1704  		if err != nil {
  1705  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1706  		}
  1707  		if fieldTypeId == thrift.STOP {
  1708  			break
  1709  		}
  1710  		switch fieldId {
  1711  		case 0:
  1712  			if fieldTypeId == thrift.STRUCT {
  1713  				if err := p.ReadField0(ctx, tp); err != nil {
  1714  					return err
  1715  				}
  1716  			} else {
  1717  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1718  					return err
  1719  				}
  1720  			}
  1721  		default:
  1722  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1723  				return err
  1724  			}
  1725  		}
  1726  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1727  			return err
  1728  		}
  1729  	}
  1730  	if err := tp.ReadStructEnd(ctx); err != nil {
  1731  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1732  	}
  1733  	return nil
  1734  }
  1735  
  1736  func (p *GetSetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  1737  	p.Success = &Response{}
  1738  	if err := p.Success.Read(ctx, tp); err != nil {
  1739  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  1740  	}
  1741  	return nil
  1742  }
  1743  
  1744  func (p *GetSetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  1745  	if err := tp.WriteStructBegin(ctx, "GetSet_result"); err != nil {
  1746  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1747  	}
  1748  	if p != nil {
  1749  		if err := p.writeField0(ctx, tp); err != nil {
  1750  			return err
  1751  		}
  1752  	}
  1753  	if err := tp.WriteFieldStop(ctx); err != nil {
  1754  		return thrift.PrependError("write field stop error: ", err)
  1755  	}
  1756  	if err := tp.WriteStructEnd(ctx); err != nil {
  1757  		return thrift.PrependError("write struct stop error: ", err)
  1758  	}
  1759  	return nil
  1760  }
  1761  
  1762  func (p *GetSetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  1763  	if p.IsSetSuccess() {
  1764  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  1765  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  1766  		}
  1767  		if err := p.Success.Write(ctx, tp); err != nil {
  1768  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  1769  		}
  1770  		if err := tp.WriteFieldEnd(ctx); err != nil {
  1771  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  1772  		}
  1773  	}
  1774  	return err
  1775  }
  1776  
  1777  func (p *GetSetResult) String() string {
  1778  	if p == nil {
  1779  		return "<nil>"
  1780  	}
  1781  	return fmt.Sprintf("GetSetResult(%+v)", *p)
  1782  }
  1783  
  1784  // Attributes:
  1785  //  - Appid
  1786  //  - Key
  1787  //  - Value
  1788  type GetSetBytesArgs struct {
  1789  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  1790  	Key   string `thrift:"key,2" db:"key" json:"key"`
  1791  	Value []byte `thrift:"value,3" db:"value" json:"value"`
  1792  }
  1793  
  1794  func NewRedisProxyGetSetBytesArgs() *GetSetBytesArgs {
  1795  	return &GetSetBytesArgs{}
  1796  }
  1797  
  1798  func (p *GetSetBytesArgs) GetAppid() string {
  1799  	return p.Appid
  1800  }
  1801  
  1802  func (p *GetSetBytesArgs) GetKey() string {
  1803  	return p.Key
  1804  }
  1805  
  1806  func (p *GetSetBytesArgs) GetValue() []byte {
  1807  	return p.Value
  1808  }
  1809  func (p *GetSetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  1810  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1811  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1812  	}
  1813  
  1814  	for {
  1815  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1816  		if err != nil {
  1817  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1818  		}
  1819  		if fieldTypeId == thrift.STOP {
  1820  			break
  1821  		}
  1822  		switch fieldId {
  1823  		case 1:
  1824  			if fieldTypeId == thrift.STRING {
  1825  				if err := p.ReadField1(ctx, tp); err != nil {
  1826  					return err
  1827  				}
  1828  			} else {
  1829  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1830  					return err
  1831  				}
  1832  			}
  1833  		case 2:
  1834  			if fieldTypeId == thrift.STRING {
  1835  				if err := p.ReadField2(ctx, tp); err != nil {
  1836  					return err
  1837  				}
  1838  			} else {
  1839  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1840  					return err
  1841  				}
  1842  			}
  1843  		case 3:
  1844  			if fieldTypeId == thrift.STRING {
  1845  				if err := p.ReadField3(ctx, tp); err != nil {
  1846  					return err
  1847  				}
  1848  			} else {
  1849  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1850  					return err
  1851  				}
  1852  			}
  1853  		default:
  1854  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  1855  				return err
  1856  			}
  1857  		}
  1858  		if err := tp.ReadFieldEnd(ctx); err != nil {
  1859  			return err
  1860  		}
  1861  	}
  1862  	if err := tp.ReadStructEnd(ctx); err != nil {
  1863  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  1864  	}
  1865  	return nil
  1866  }
  1867  
  1868  func (p *GetSetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  1869  	if v, err := tp.ReadString(ctx); err != nil {
  1870  		return thrift.PrependError("error reading field 1: ", err)
  1871  	} else {
  1872  		p.Appid = v
  1873  	}
  1874  	return nil
  1875  }
  1876  
  1877  func (p *GetSetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  1878  	if v, err := tp.ReadString(ctx); err != nil {
  1879  		return thrift.PrependError("error reading field 2: ", err)
  1880  	} else {
  1881  		p.Key = v
  1882  	}
  1883  	return nil
  1884  }
  1885  
  1886  func (p *GetSetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  1887  	if v, err := tp.ReadBinary(ctx); err != nil {
  1888  		return thrift.PrependError("error reading field 3: ", err)
  1889  	} else {
  1890  		p.Value = v
  1891  	}
  1892  	return nil
  1893  }
  1894  
  1895  func (p *GetSetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  1896  	if err := tp.WriteStructBegin(ctx, "GetSetBytes_args"); err != nil {
  1897  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  1898  	}
  1899  	if p != nil {
  1900  		if err := p.writeField1(ctx, tp); err != nil {
  1901  			return err
  1902  		}
  1903  		if err := p.writeField2(ctx, tp); err != nil {
  1904  			return err
  1905  		}
  1906  		if err := p.writeField3(ctx, tp); err != nil {
  1907  			return err
  1908  		}
  1909  	}
  1910  	if err := tp.WriteFieldStop(ctx); err != nil {
  1911  		return thrift.PrependError("write field stop error: ", err)
  1912  	}
  1913  	if err := tp.WriteStructEnd(ctx); err != nil {
  1914  		return thrift.PrependError("write struct stop error: ", err)
  1915  	}
  1916  	return nil
  1917  }
  1918  
  1919  func (p *GetSetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  1920  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  1921  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  1922  	}
  1923  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  1924  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  1925  	}
  1926  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1927  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  1928  	}
  1929  	return err
  1930  }
  1931  
  1932  func (p *GetSetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  1933  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  1934  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  1935  	}
  1936  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  1937  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  1938  	}
  1939  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1940  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  1941  	}
  1942  	return err
  1943  }
  1944  
  1945  func (p *GetSetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  1946  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  1947  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  1948  	}
  1949  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
  1950  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  1951  	}
  1952  	if err := tp.WriteFieldEnd(ctx); err != nil {
  1953  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  1954  	}
  1955  	return err
  1956  }
  1957  
  1958  func (p *GetSetBytesArgs) String() string {
  1959  	if p == nil {
  1960  		return "<nil>"
  1961  	}
  1962  	return fmt.Sprintf("GetSetBytesArgs(%+v)", *p)
  1963  }
  1964  
  1965  // Attributes:
  1966  //  - Success
  1967  type GetSetBytesResult struct {
  1968  	Success *BytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  1969  }
  1970  
  1971  func NewGetSetBytesResult() *GetSetBytesResult {
  1972  	return &GetSetBytesResult{}
  1973  }
  1974  
  1975  var GetSetBytesResult_Success_DEFAULT *BytesResponse
  1976  
  1977  func (p *GetSetBytesResult) GetSuccess() *BytesResponse {
  1978  	if !p.IsSetSuccess() {
  1979  		return GetSetBytesResult_Success_DEFAULT
  1980  	}
  1981  	return p.Success
  1982  }
  1983  func (p *GetSetBytesResult) IsSetSuccess() bool {
  1984  	return p.Success != nil
  1985  }
  1986  
  1987  func (p *GetSetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  1988  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  1989  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  1990  	}
  1991  
  1992  	for {
  1993  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  1994  		if err != nil {
  1995  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  1996  		}
  1997  		if fieldTypeId == thrift.STOP {
  1998  			break
  1999  		}
  2000  		switch fieldId {
  2001  		case 0:
  2002  			if fieldTypeId == thrift.STRUCT {
  2003  				if err := p.ReadField0(ctx, tp); err != nil {
  2004  					return err
  2005  				}
  2006  			} else {
  2007  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2008  					return err
  2009  				}
  2010  			}
  2011  		default:
  2012  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2013  				return err
  2014  			}
  2015  		}
  2016  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2017  			return err
  2018  		}
  2019  	}
  2020  	if err := tp.ReadStructEnd(ctx); err != nil {
  2021  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2022  	}
  2023  	return nil
  2024  }
  2025  
  2026  func (p *GetSetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  2027  	p.Success = &BytesResponse{}
  2028  	if err := p.Success.Read(ctx, tp); err != nil {
  2029  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  2030  	}
  2031  	return nil
  2032  }
  2033  
  2034  func (p *GetSetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  2035  	if err := tp.WriteStructBegin(ctx, "GetSetBytes_result"); err != nil {
  2036  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2037  	}
  2038  	if p != nil {
  2039  		if err := p.writeField0(ctx, tp); err != nil {
  2040  			return err
  2041  		}
  2042  	}
  2043  	if err := tp.WriteFieldStop(ctx); err != nil {
  2044  		return thrift.PrependError("write field stop error: ", err)
  2045  	}
  2046  	if err := tp.WriteStructEnd(ctx); err != nil {
  2047  		return thrift.PrependError("write struct stop error: ", err)
  2048  	}
  2049  	return nil
  2050  }
  2051  
  2052  func (p *GetSetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  2053  	if p.IsSetSuccess() {
  2054  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  2055  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  2056  		}
  2057  		if err := p.Success.Write(ctx, tp); err != nil {
  2058  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  2059  		}
  2060  		if err := tp.WriteFieldEnd(ctx); err != nil {
  2061  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  2062  		}
  2063  	}
  2064  	return err
  2065  }
  2066  
  2067  func (p *GetSetBytesResult) String() string {
  2068  	if p == nil {
  2069  		return "<nil>"
  2070  	}
  2071  	return fmt.Sprintf("GetSetBytesResult(%+v)", *p)
  2072  }
  2073  
  2074  // Attributes:
  2075  //  - Appid
  2076  //  - Key
  2077  //  - Value
  2078  //  - TTL
  2079  type SetArgs struct {
  2080  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  2081  	Key   string `thrift:"key,2" db:"key" json:"key"`
  2082  	Value string `thrift:"value,3" db:"value" json:"value"`
  2083  	TTL   int64  `thrift:"ttl,4" db:"ttl" json:"ttl"`
  2084  }
  2085  
  2086  func NewRedisProxySetArgs() *SetArgs {
  2087  	return &SetArgs{}
  2088  }
  2089  
  2090  func (p *SetArgs) GetAppid() string {
  2091  	return p.Appid
  2092  }
  2093  
  2094  func (p *SetArgs) GetKey() string {
  2095  	return p.Key
  2096  }
  2097  
  2098  func (p *SetArgs) GetValue() string {
  2099  	return p.Value
  2100  }
  2101  
  2102  func (p *SetArgs) GetTTL() int64 {
  2103  	return p.TTL
  2104  }
  2105  func (p *SetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  2106  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2107  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2108  	}
  2109  
  2110  	for {
  2111  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2112  		if err != nil {
  2113  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2114  		}
  2115  		if fieldTypeId == thrift.STOP {
  2116  			break
  2117  		}
  2118  		switch fieldId {
  2119  		case 1:
  2120  			if fieldTypeId == thrift.STRING {
  2121  				if err := p.ReadField1(ctx, tp); err != nil {
  2122  					return err
  2123  				}
  2124  			} else {
  2125  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2126  					return err
  2127  				}
  2128  			}
  2129  		case 2:
  2130  			if fieldTypeId == thrift.STRING {
  2131  				if err := p.ReadField2(ctx, tp); err != nil {
  2132  					return err
  2133  				}
  2134  			} else {
  2135  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2136  					return err
  2137  				}
  2138  			}
  2139  		case 3:
  2140  			if fieldTypeId == thrift.STRING {
  2141  				if err := p.ReadField3(ctx, tp); err != nil {
  2142  					return err
  2143  				}
  2144  			} else {
  2145  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2146  					return err
  2147  				}
  2148  			}
  2149  		case 4:
  2150  			if fieldTypeId == thrift.I64 {
  2151  				if err := p.ReadField4(ctx, tp); err != nil {
  2152  					return err
  2153  				}
  2154  			} else {
  2155  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2156  					return err
  2157  				}
  2158  			}
  2159  		default:
  2160  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2161  				return err
  2162  			}
  2163  		}
  2164  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2165  			return err
  2166  		}
  2167  	}
  2168  	if err := tp.ReadStructEnd(ctx); err != nil {
  2169  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2170  	}
  2171  	return nil
  2172  }
  2173  
  2174  func (p *SetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  2175  	if v, err := tp.ReadString(ctx); err != nil {
  2176  		return thrift.PrependError("error reading field 1: ", err)
  2177  	} else {
  2178  		p.Appid = v
  2179  	}
  2180  	return nil
  2181  }
  2182  
  2183  func (p *SetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  2184  	if v, err := tp.ReadString(ctx); err != nil {
  2185  		return thrift.PrependError("error reading field 2: ", err)
  2186  	} else {
  2187  		p.Key = v
  2188  	}
  2189  	return nil
  2190  }
  2191  
  2192  func (p *SetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  2193  	if v, err := tp.ReadString(ctx); err != nil {
  2194  		return thrift.PrependError("error reading field 3: ", err)
  2195  	} else {
  2196  		p.Value = v
  2197  	}
  2198  	return nil
  2199  }
  2200  
  2201  func (p *SetArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  2202  	if v, err := tp.ReadI64(ctx); err != nil {
  2203  		return thrift.PrependError("error reading field 4: ", err)
  2204  	} else {
  2205  		p.TTL = v
  2206  	}
  2207  	return nil
  2208  }
  2209  
  2210  func (p *SetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  2211  	if err := tp.WriteStructBegin(ctx, "Set_args"); err != nil {
  2212  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2213  	}
  2214  	if p != nil {
  2215  		if err := p.writeField1(ctx, tp); err != nil {
  2216  			return err
  2217  		}
  2218  		if err := p.writeField2(ctx, tp); err != nil {
  2219  			return err
  2220  		}
  2221  		if err := p.writeField3(ctx, tp); err != nil {
  2222  			return err
  2223  		}
  2224  		if err := p.writeField4(ctx, tp); err != nil {
  2225  			return err
  2226  		}
  2227  	}
  2228  	if err := tp.WriteFieldStop(ctx); err != nil {
  2229  		return thrift.PrependError("write field stop error: ", err)
  2230  	}
  2231  	if err := tp.WriteStructEnd(ctx); err != nil {
  2232  		return thrift.PrependError("write struct stop error: ", err)
  2233  	}
  2234  	return nil
  2235  }
  2236  
  2237  func (p *SetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  2238  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  2239  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  2240  	}
  2241  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  2242  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  2243  	}
  2244  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2245  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  2246  	}
  2247  	return err
  2248  }
  2249  
  2250  func (p *SetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  2251  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  2252  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  2253  	}
  2254  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  2255  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  2256  	}
  2257  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2258  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  2259  	}
  2260  	return err
  2261  }
  2262  
  2263  func (p *SetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  2264  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  2265  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  2266  	}
  2267  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  2268  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  2269  	}
  2270  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2271  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  2272  	}
  2273  	return err
  2274  }
  2275  
  2276  func (p *SetArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  2277  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
  2278  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
  2279  	}
  2280  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
  2281  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
  2282  	}
  2283  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2284  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
  2285  	}
  2286  	return err
  2287  }
  2288  
  2289  func (p *SetArgs) String() string {
  2290  	if p == nil {
  2291  		return "<nil>"
  2292  	}
  2293  	return fmt.Sprintf("SetArgs(%+v)", *p)
  2294  }
  2295  
  2296  // Attributes:
  2297  //  - Success
  2298  type SetResult struct {
  2299  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  2300  }
  2301  
  2302  func NewRedisProxySetResult() *SetResult {
  2303  	return &SetResult{}
  2304  }
  2305  
  2306  var RedisProxySetResult_Success_DEFAULT *Response
  2307  
  2308  func (p *SetResult) GetSuccess() *Response {
  2309  	if !p.IsSetSuccess() {
  2310  		return RedisProxySetResult_Success_DEFAULT
  2311  	}
  2312  	return p.Success
  2313  }
  2314  func (p *SetResult) IsSetSuccess() bool {
  2315  	return p.Success != nil
  2316  }
  2317  
  2318  func (p *SetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  2319  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2320  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2321  	}
  2322  
  2323  	for {
  2324  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2325  		if err != nil {
  2326  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2327  		}
  2328  		if fieldTypeId == thrift.STOP {
  2329  			break
  2330  		}
  2331  		switch fieldId {
  2332  		case 0:
  2333  			if fieldTypeId == thrift.STRUCT {
  2334  				if err := p.ReadField0(ctx, tp); err != nil {
  2335  					return err
  2336  				}
  2337  			} else {
  2338  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2339  					return err
  2340  				}
  2341  			}
  2342  		default:
  2343  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2344  				return err
  2345  			}
  2346  		}
  2347  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2348  			return err
  2349  		}
  2350  	}
  2351  	if err := tp.ReadStructEnd(ctx); err != nil {
  2352  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2353  	}
  2354  	return nil
  2355  }
  2356  
  2357  func (p *SetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  2358  	p.Success = &Response{}
  2359  	if err := p.Success.Read(ctx, tp); err != nil {
  2360  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  2361  	}
  2362  	return nil
  2363  }
  2364  
  2365  func (p *SetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  2366  	if err := tp.WriteStructBegin(ctx, "Set_result"); err != nil {
  2367  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2368  	}
  2369  	if p != nil {
  2370  		if err := p.writeField0(ctx, tp); err != nil {
  2371  			return err
  2372  		}
  2373  	}
  2374  	if err := tp.WriteFieldStop(ctx); err != nil {
  2375  		return thrift.PrependError("write field stop error: ", err)
  2376  	}
  2377  	if err := tp.WriteStructEnd(ctx); err != nil {
  2378  		return thrift.PrependError("write struct stop error: ", err)
  2379  	}
  2380  	return nil
  2381  }
  2382  
  2383  func (p *SetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  2384  	if p.IsSetSuccess() {
  2385  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  2386  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  2387  		}
  2388  		if err := p.Success.Write(ctx, tp); err != nil {
  2389  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  2390  		}
  2391  		if err := tp.WriteFieldEnd(ctx); err != nil {
  2392  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  2393  		}
  2394  	}
  2395  	return err
  2396  }
  2397  
  2398  func (p *SetResult) String() string {
  2399  	if p == nil {
  2400  		return "<nil>"
  2401  	}
  2402  	return fmt.Sprintf("SetResult(%+v)", *p)
  2403  }
  2404  
  2405  // Attributes:
  2406  //  - Appid
  2407  //  - Key
  2408  //  - Value
  2409  //  - TTL
  2410  type SetBytesArgs struct {
  2411  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  2412  	Key   string `thrift:"key,2" db:"key" json:"key"`
  2413  	Value []byte `thrift:"value,3" db:"value" json:"value"`
  2414  	TTL   int64  `thrift:"ttl,4" db:"ttl" json:"ttl"`
  2415  }
  2416  
  2417  func NewSetBytesArgs() *SetBytesArgs {
  2418  	return &SetBytesArgs{}
  2419  }
  2420  
  2421  func (p *SetBytesArgs) GetAppid() string {
  2422  	return p.Appid
  2423  }
  2424  
  2425  func (p *SetBytesArgs) GetKey() string {
  2426  	return p.Key
  2427  }
  2428  
  2429  func (p *SetBytesArgs) GetValue() []byte {
  2430  	return p.Value
  2431  }
  2432  
  2433  func (p *SetBytesArgs) GetTTL() int64 {
  2434  	return p.TTL
  2435  }
  2436  func (p *SetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  2437  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2438  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2439  	}
  2440  
  2441  	for {
  2442  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2443  		if err != nil {
  2444  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2445  		}
  2446  		if fieldTypeId == thrift.STOP {
  2447  			break
  2448  		}
  2449  		switch fieldId {
  2450  		case 1:
  2451  			if fieldTypeId == thrift.STRING {
  2452  				if err := p.ReadField1(ctx, tp); err != nil {
  2453  					return err
  2454  				}
  2455  			} else {
  2456  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2457  					return err
  2458  				}
  2459  			}
  2460  		case 2:
  2461  			if fieldTypeId == thrift.STRING {
  2462  				if err := p.ReadField2(ctx, tp); err != nil {
  2463  					return err
  2464  				}
  2465  			} else {
  2466  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2467  					return err
  2468  				}
  2469  			}
  2470  		case 3:
  2471  			if fieldTypeId == thrift.STRING {
  2472  				if err := p.ReadField3(ctx, tp); err != nil {
  2473  					return err
  2474  				}
  2475  			} else {
  2476  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2477  					return err
  2478  				}
  2479  			}
  2480  		case 4:
  2481  			if fieldTypeId == thrift.I64 {
  2482  				if err := p.ReadField4(ctx, tp); err != nil {
  2483  					return err
  2484  				}
  2485  			} else {
  2486  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2487  					return err
  2488  				}
  2489  			}
  2490  		default:
  2491  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2492  				return err
  2493  			}
  2494  		}
  2495  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2496  			return err
  2497  		}
  2498  	}
  2499  	if err := tp.ReadStructEnd(ctx); err != nil {
  2500  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2501  	}
  2502  	return nil
  2503  }
  2504  
  2505  func (p *SetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  2506  	if v, err := tp.ReadString(ctx); err != nil {
  2507  		return thrift.PrependError("error reading field 1: ", err)
  2508  	} else {
  2509  		p.Appid = v
  2510  	}
  2511  	return nil
  2512  }
  2513  
  2514  func (p *SetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  2515  	if v, err := tp.ReadString(ctx); err != nil {
  2516  		return thrift.PrependError("error reading field 2: ", err)
  2517  	} else {
  2518  		p.Key = v
  2519  	}
  2520  	return nil
  2521  }
  2522  
  2523  func (p *SetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  2524  	if v, err := tp.ReadBinary(ctx); err != nil {
  2525  		return thrift.PrependError("error reading field 3: ", err)
  2526  	} else {
  2527  		p.Value = v
  2528  	}
  2529  	return nil
  2530  }
  2531  
  2532  func (p *SetBytesArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  2533  	if v, err := tp.ReadI64(ctx); err != nil {
  2534  		return thrift.PrependError("error reading field 4: ", err)
  2535  	} else {
  2536  		p.TTL = v
  2537  	}
  2538  	return nil
  2539  }
  2540  
  2541  func (p *SetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  2542  	if err := tp.WriteStructBegin(ctx, "SetBytes_args"); err != nil {
  2543  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2544  	}
  2545  	if p != nil {
  2546  		if err := p.writeField1(ctx, tp); err != nil {
  2547  			return err
  2548  		}
  2549  		if err := p.writeField2(ctx, tp); err != nil {
  2550  			return err
  2551  		}
  2552  		if err := p.writeField3(ctx, tp); err != nil {
  2553  			return err
  2554  		}
  2555  		if err := p.writeField4(ctx, tp); err != nil {
  2556  			return err
  2557  		}
  2558  	}
  2559  	if err := tp.WriteFieldStop(ctx); err != nil {
  2560  		return thrift.PrependError("write field stop error: ", err)
  2561  	}
  2562  	if err := tp.WriteStructEnd(ctx); err != nil {
  2563  		return thrift.PrependError("write struct stop error: ", err)
  2564  	}
  2565  	return nil
  2566  }
  2567  
  2568  func (p *SetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  2569  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  2570  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  2571  	}
  2572  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  2573  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  2574  	}
  2575  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2576  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  2577  	}
  2578  	return err
  2579  }
  2580  
  2581  func (p *SetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  2582  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  2583  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  2584  	}
  2585  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  2586  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  2587  	}
  2588  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2589  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  2590  	}
  2591  	return err
  2592  }
  2593  
  2594  func (p *SetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  2595  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  2596  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  2597  	}
  2598  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
  2599  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  2600  	}
  2601  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2602  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  2603  	}
  2604  	return err
  2605  }
  2606  
  2607  func (p *SetBytesArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  2608  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
  2609  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
  2610  	}
  2611  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
  2612  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
  2613  	}
  2614  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2615  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
  2616  	}
  2617  	return err
  2618  }
  2619  
  2620  func (p *SetBytesArgs) String() string {
  2621  	if p == nil {
  2622  		return "<nil>"
  2623  	}
  2624  	return fmt.Sprintf("SetBytesArgs(%+v)", *p)
  2625  }
  2626  
  2627  // Attributes:
  2628  //  - Success
  2629  type RedisProxySetBytesResult struct {
  2630  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  2631  }
  2632  
  2633  func NewRedisProxySetBytesResult() *RedisProxySetBytesResult {
  2634  	return &RedisProxySetBytesResult{}
  2635  }
  2636  
  2637  var RedisProxySetBytesResult_Success_DEFAULT *Response
  2638  
  2639  func (p *RedisProxySetBytesResult) GetSuccess() *Response {
  2640  	if !p.IsSetSuccess() {
  2641  		return RedisProxySetBytesResult_Success_DEFAULT
  2642  	}
  2643  	return p.Success
  2644  }
  2645  func (p *RedisProxySetBytesResult) IsSetSuccess() bool {
  2646  	return p.Success != nil
  2647  }
  2648  
  2649  func (p *RedisProxySetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  2650  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2651  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2652  	}
  2653  
  2654  	for {
  2655  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2656  		if err != nil {
  2657  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2658  		}
  2659  		if fieldTypeId == thrift.STOP {
  2660  			break
  2661  		}
  2662  		switch fieldId {
  2663  		case 0:
  2664  			if fieldTypeId == thrift.STRUCT {
  2665  				if err := p.ReadField0(ctx, tp); err != nil {
  2666  					return err
  2667  				}
  2668  			} else {
  2669  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2670  					return err
  2671  				}
  2672  			}
  2673  		default:
  2674  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2675  				return err
  2676  			}
  2677  		}
  2678  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2679  			return err
  2680  		}
  2681  	}
  2682  	if err := tp.ReadStructEnd(ctx); err != nil {
  2683  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2684  	}
  2685  	return nil
  2686  }
  2687  
  2688  func (p *RedisProxySetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  2689  	p.Success = &Response{}
  2690  	if err := p.Success.Read(ctx, tp); err != nil {
  2691  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  2692  	}
  2693  	return nil
  2694  }
  2695  
  2696  func (p *RedisProxySetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  2697  	if err := tp.WriteStructBegin(ctx, "SetBytes_result"); err != nil {
  2698  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2699  	}
  2700  	if p != nil {
  2701  		if err := p.writeField0(ctx, tp); err != nil {
  2702  			return err
  2703  		}
  2704  	}
  2705  	if err := tp.WriteFieldStop(ctx); err != nil {
  2706  		return thrift.PrependError("write field stop error: ", err)
  2707  	}
  2708  	if err := tp.WriteStructEnd(ctx); err != nil {
  2709  		return thrift.PrependError("write struct stop error: ", err)
  2710  	}
  2711  	return nil
  2712  }
  2713  
  2714  func (p *RedisProxySetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  2715  	if p.IsSetSuccess() {
  2716  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  2717  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  2718  		}
  2719  		if err := p.Success.Write(ctx, tp); err != nil {
  2720  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  2721  		}
  2722  		if err := tp.WriteFieldEnd(ctx); err != nil {
  2723  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  2724  		}
  2725  	}
  2726  	return err
  2727  }
  2728  
  2729  func (p *RedisProxySetBytesResult) String() string {
  2730  	if p == nil {
  2731  		return "<nil>"
  2732  	}
  2733  	return fmt.Sprintf("RedisProxySetBytesResult(%+v)", *p)
  2734  }
  2735  
  2736  // Attributes:
  2737  //  - Appid
  2738  //  - Key
  2739  //  - Value
  2740  //  - TTL
  2741  type SetNXArgs struct {
  2742  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  2743  	Key   string `thrift:"key,2" db:"key" json:"key"`
  2744  	Value string `thrift:"value,3" db:"value" json:"value"`
  2745  	TTL   int64  `thrift:"ttl,4" db:"ttl" json:"ttl"`
  2746  }
  2747  
  2748  func NewRedisProxySetNXArgs() *SetNXArgs {
  2749  	return &SetNXArgs{}
  2750  }
  2751  
  2752  func (p *SetNXArgs) GetAppid() string {
  2753  	return p.Appid
  2754  }
  2755  
  2756  func (p *SetNXArgs) GetKey() string {
  2757  	return p.Key
  2758  }
  2759  
  2760  func (p *SetNXArgs) GetValue() string {
  2761  	return p.Value
  2762  }
  2763  
  2764  func (p *SetNXArgs) GetTTL() int64 {
  2765  	return p.TTL
  2766  }
  2767  func (p *SetNXArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  2768  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2769  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2770  	}
  2771  
  2772  	for {
  2773  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2774  		if err != nil {
  2775  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2776  		}
  2777  		if fieldTypeId == thrift.STOP {
  2778  			break
  2779  		}
  2780  		switch fieldId {
  2781  		case 1:
  2782  			if fieldTypeId == thrift.STRING {
  2783  				if err := p.ReadField1(ctx, tp); err != nil {
  2784  					return err
  2785  				}
  2786  			} else {
  2787  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2788  					return err
  2789  				}
  2790  			}
  2791  		case 2:
  2792  			if fieldTypeId == thrift.STRING {
  2793  				if err := p.ReadField2(ctx, tp); err != nil {
  2794  					return err
  2795  				}
  2796  			} else {
  2797  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2798  					return err
  2799  				}
  2800  			}
  2801  		case 3:
  2802  			if fieldTypeId == thrift.STRING {
  2803  				if err := p.ReadField3(ctx, tp); err != nil {
  2804  					return err
  2805  				}
  2806  			} else {
  2807  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2808  					return err
  2809  				}
  2810  			}
  2811  		case 4:
  2812  			if fieldTypeId == thrift.I64 {
  2813  				if err := p.ReadField4(ctx, tp); err != nil {
  2814  					return err
  2815  				}
  2816  			} else {
  2817  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2818  					return err
  2819  				}
  2820  			}
  2821  		default:
  2822  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  2823  				return err
  2824  			}
  2825  		}
  2826  		if err := tp.ReadFieldEnd(ctx); err != nil {
  2827  			return err
  2828  		}
  2829  	}
  2830  	if err := tp.ReadStructEnd(ctx); err != nil {
  2831  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  2832  	}
  2833  	return nil
  2834  }
  2835  
  2836  func (p *SetNXArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  2837  	if v, err := tp.ReadString(ctx); err != nil {
  2838  		return thrift.PrependError("error reading field 1: ", err)
  2839  	} else {
  2840  		p.Appid = v
  2841  	}
  2842  	return nil
  2843  }
  2844  
  2845  func (p *SetNXArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  2846  	if v, err := tp.ReadString(ctx); err != nil {
  2847  		return thrift.PrependError("error reading field 2: ", err)
  2848  	} else {
  2849  		p.Key = v
  2850  	}
  2851  	return nil
  2852  }
  2853  
  2854  func (p *SetNXArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  2855  	if v, err := tp.ReadString(ctx); err != nil {
  2856  		return thrift.PrependError("error reading field 3: ", err)
  2857  	} else {
  2858  		p.Value = v
  2859  	}
  2860  	return nil
  2861  }
  2862  
  2863  func (p *SetNXArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  2864  	if v, err := tp.ReadI64(ctx); err != nil {
  2865  		return thrift.PrependError("error reading field 4: ", err)
  2866  	} else {
  2867  		p.TTL = v
  2868  	}
  2869  	return nil
  2870  }
  2871  
  2872  func (p *SetNXArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  2873  	if err := tp.WriteStructBegin(ctx, "SetNX_args"); err != nil {
  2874  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  2875  	}
  2876  	if p != nil {
  2877  		if err := p.writeField1(ctx, tp); err != nil {
  2878  			return err
  2879  		}
  2880  		if err := p.writeField2(ctx, tp); err != nil {
  2881  			return err
  2882  		}
  2883  		if err := p.writeField3(ctx, tp); err != nil {
  2884  			return err
  2885  		}
  2886  		if err := p.writeField4(ctx, tp); err != nil {
  2887  			return err
  2888  		}
  2889  	}
  2890  	if err := tp.WriteFieldStop(ctx); err != nil {
  2891  		return thrift.PrependError("write field stop error: ", err)
  2892  	}
  2893  	if err := tp.WriteStructEnd(ctx); err != nil {
  2894  		return thrift.PrependError("write struct stop error: ", err)
  2895  	}
  2896  	return nil
  2897  }
  2898  
  2899  func (p *SetNXArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  2900  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  2901  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  2902  	}
  2903  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  2904  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  2905  	}
  2906  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2907  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  2908  	}
  2909  	return err
  2910  }
  2911  
  2912  func (p *SetNXArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  2913  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  2914  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  2915  	}
  2916  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  2917  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  2918  	}
  2919  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2920  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  2921  	}
  2922  	return err
  2923  }
  2924  
  2925  func (p *SetNXArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  2926  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  2927  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  2928  	}
  2929  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  2930  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  2931  	}
  2932  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2933  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  2934  	}
  2935  	return err
  2936  }
  2937  
  2938  func (p *SetNXArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  2939  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
  2940  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
  2941  	}
  2942  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
  2943  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
  2944  	}
  2945  	if err := tp.WriteFieldEnd(ctx); err != nil {
  2946  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
  2947  	}
  2948  	return err
  2949  }
  2950  
  2951  func (p *SetNXArgs) String() string {
  2952  	if p == nil {
  2953  		return "<nil>"
  2954  	}
  2955  	return fmt.Sprintf("SetNXArgs(%+v)", *p)
  2956  }
  2957  
  2958  // Attributes:
  2959  //  - Success
  2960  type SetNXResult struct {
  2961  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  2962  }
  2963  
  2964  func NewRedisProxySetNXResult() *SetNXResult {
  2965  	return &SetNXResult{}
  2966  }
  2967  
  2968  var RedisProxySetNXResult_Success_DEFAULT *Response
  2969  
  2970  func (p *SetNXResult) GetSuccess() *Response {
  2971  	if !p.IsSetSuccess() {
  2972  		return RedisProxySetNXResult_Success_DEFAULT
  2973  	}
  2974  	return p.Success
  2975  }
  2976  func (p *SetNXResult) IsSetSuccess() bool {
  2977  	return p.Success != nil
  2978  }
  2979  
  2980  func (p *SetNXResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  2981  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  2982  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  2983  	}
  2984  
  2985  	for {
  2986  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  2987  		if err != nil {
  2988  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  2989  		}
  2990  		if fieldTypeId == thrift.STOP {
  2991  			break
  2992  		}
  2993  		switch fieldId {
  2994  		case 0:
  2995  			if fieldTypeId == thrift.STRUCT {
  2996  				if err := p.ReadField0(ctx, tp); err != nil {
  2997  					return err
  2998  				}
  2999  			} else {
  3000  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3001  					return err
  3002  				}
  3003  			}
  3004  		default:
  3005  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3006  				return err
  3007  			}
  3008  		}
  3009  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3010  			return err
  3011  		}
  3012  	}
  3013  	if err := tp.ReadStructEnd(ctx); err != nil {
  3014  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3015  	}
  3016  	return nil
  3017  }
  3018  
  3019  func (p *SetNXResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  3020  	p.Success = &Response{}
  3021  	if err := p.Success.Read(ctx, tp); err != nil {
  3022  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  3023  	}
  3024  	return nil
  3025  }
  3026  
  3027  func (p *SetNXResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  3028  	if err := tp.WriteStructBegin(ctx, "SetNX_result"); err != nil {
  3029  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3030  	}
  3031  	if p != nil {
  3032  		if err := p.writeField0(ctx, tp); err != nil {
  3033  			return err
  3034  		}
  3035  	}
  3036  	if err := tp.WriteFieldStop(ctx); err != nil {
  3037  		return thrift.PrependError("write field stop error: ", err)
  3038  	}
  3039  	if err := tp.WriteStructEnd(ctx); err != nil {
  3040  		return thrift.PrependError("write struct stop error: ", err)
  3041  	}
  3042  	return nil
  3043  }
  3044  
  3045  func (p *SetNXResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  3046  	if p.IsSetSuccess() {
  3047  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  3048  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  3049  		}
  3050  		if err := p.Success.Write(ctx, tp); err != nil {
  3051  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  3052  		}
  3053  		if err := tp.WriteFieldEnd(ctx); err != nil {
  3054  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  3055  		}
  3056  	}
  3057  	return err
  3058  }
  3059  
  3060  func (p *SetNXResult) String() string {
  3061  	if p == nil {
  3062  		return "<nil>"
  3063  	}
  3064  	return fmt.Sprintf("SetNXResult(%+v)", *p)
  3065  }
  3066  
  3067  // Attributes:
  3068  //  - Appid
  3069  //  - Key
  3070  //  - Value
  3071  //  - TTL
  3072  type SetNXBytesArgs struct {
  3073  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  3074  	Key   string `thrift:"key,2" db:"key" json:"key"`
  3075  	Value []byte `thrift:"value,3" db:"value" json:"value"`
  3076  	TTL   int64  `thrift:"ttl,4" db:"ttl" json:"ttl"`
  3077  }
  3078  
  3079  func NewRedisProxySetNXBytesArgs() *SetNXBytesArgs {
  3080  	return &SetNXBytesArgs{}
  3081  }
  3082  
  3083  func (p *SetNXBytesArgs) GetAppid() string {
  3084  	return p.Appid
  3085  }
  3086  
  3087  func (p *SetNXBytesArgs) GetKey() string {
  3088  	return p.Key
  3089  }
  3090  
  3091  func (p *SetNXBytesArgs) GetValue() []byte {
  3092  	return p.Value
  3093  }
  3094  
  3095  func (p *SetNXBytesArgs) GetTTL() int64 {
  3096  	return p.TTL
  3097  }
  3098  func (p *SetNXBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  3099  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3100  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3101  	}
  3102  
  3103  	for {
  3104  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3105  		if err != nil {
  3106  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3107  		}
  3108  		if fieldTypeId == thrift.STOP {
  3109  			break
  3110  		}
  3111  		switch fieldId {
  3112  		case 1:
  3113  			if fieldTypeId == thrift.STRING {
  3114  				if err := p.ReadField1(ctx, tp); err != nil {
  3115  					return err
  3116  				}
  3117  			} else {
  3118  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3119  					return err
  3120  				}
  3121  			}
  3122  		case 2:
  3123  			if fieldTypeId == thrift.STRING {
  3124  				if err := p.ReadField2(ctx, tp); err != nil {
  3125  					return err
  3126  				}
  3127  			} else {
  3128  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3129  					return err
  3130  				}
  3131  			}
  3132  		case 3:
  3133  			if fieldTypeId == thrift.STRING {
  3134  				if err := p.ReadField3(ctx, tp); err != nil {
  3135  					return err
  3136  				}
  3137  			} else {
  3138  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3139  					return err
  3140  				}
  3141  			}
  3142  		case 4:
  3143  			if fieldTypeId == thrift.I64 {
  3144  				if err := p.ReadField4(ctx, tp); err != nil {
  3145  					return err
  3146  				}
  3147  			} else {
  3148  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3149  					return err
  3150  				}
  3151  			}
  3152  		default:
  3153  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3154  				return err
  3155  			}
  3156  		}
  3157  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3158  			return err
  3159  		}
  3160  	}
  3161  	if err := tp.ReadStructEnd(ctx); err != nil {
  3162  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3163  	}
  3164  	return nil
  3165  }
  3166  
  3167  func (p *SetNXBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  3168  	if v, err := tp.ReadString(ctx); err != nil {
  3169  		return thrift.PrependError("error reading field 1: ", err)
  3170  	} else {
  3171  		p.Appid = v
  3172  	}
  3173  	return nil
  3174  }
  3175  
  3176  func (p *SetNXBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  3177  	if v, err := tp.ReadString(ctx); err != nil {
  3178  		return thrift.PrependError("error reading field 2: ", err)
  3179  	} else {
  3180  		p.Key = v
  3181  	}
  3182  	return nil
  3183  }
  3184  
  3185  func (p *SetNXBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  3186  	if v, err := tp.ReadBinary(ctx); err != nil {
  3187  		return thrift.PrependError("error reading field 3: ", err)
  3188  	} else {
  3189  		p.Value = v
  3190  	}
  3191  	return nil
  3192  }
  3193  
  3194  func (p *SetNXBytesArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  3195  	if v, err := tp.ReadI64(ctx); err != nil {
  3196  		return thrift.PrependError("error reading field 4: ", err)
  3197  	} else {
  3198  		p.TTL = v
  3199  	}
  3200  	return nil
  3201  }
  3202  
  3203  func (p *SetNXBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  3204  	if err := tp.WriteStructBegin(ctx, "SetNXBytes_args"); err != nil {
  3205  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3206  	}
  3207  	if p != nil {
  3208  		if err := p.writeField1(ctx, tp); err != nil {
  3209  			return err
  3210  		}
  3211  		if err := p.writeField2(ctx, tp); err != nil {
  3212  			return err
  3213  		}
  3214  		if err := p.writeField3(ctx, tp); err != nil {
  3215  			return err
  3216  		}
  3217  		if err := p.writeField4(ctx, tp); err != nil {
  3218  			return err
  3219  		}
  3220  	}
  3221  	if err := tp.WriteFieldStop(ctx); err != nil {
  3222  		return thrift.PrependError("write field stop error: ", err)
  3223  	}
  3224  	if err := tp.WriteStructEnd(ctx); err != nil {
  3225  		return thrift.PrependError("write struct stop error: ", err)
  3226  	}
  3227  	return nil
  3228  }
  3229  
  3230  func (p *SetNXBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  3231  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  3232  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  3233  	}
  3234  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  3235  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  3236  	}
  3237  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3238  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  3239  	}
  3240  	return err
  3241  }
  3242  
  3243  func (p *SetNXBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  3244  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  3245  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  3246  	}
  3247  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  3248  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  3249  	}
  3250  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3251  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  3252  	}
  3253  	return err
  3254  }
  3255  
  3256  func (p *SetNXBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  3257  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
  3258  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
  3259  	}
  3260  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
  3261  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
  3262  	}
  3263  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3264  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
  3265  	}
  3266  	return err
  3267  }
  3268  
  3269  func (p *SetNXBytesArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  3270  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
  3271  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
  3272  	}
  3273  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
  3274  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
  3275  	}
  3276  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3277  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
  3278  	}
  3279  	return err
  3280  }
  3281  
  3282  func (p *SetNXBytesArgs) String() string {
  3283  	if p == nil {
  3284  		return "<nil>"
  3285  	}
  3286  	return fmt.Sprintf("SetNXBytesArgs(%+v)", *p)
  3287  }
  3288  
  3289  // Attributes:
  3290  //  - Success
  3291  type SetNXBytesResult struct {
  3292  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  3293  }
  3294  
  3295  func NewRedisProxySetNXBytesResult() *SetNXBytesResult {
  3296  	return &SetNXBytesResult{}
  3297  }
  3298  
  3299  var RedisProxySetNXBytesResult_Success_DEFAULT *Response
  3300  
  3301  func (p *SetNXBytesResult) GetSuccess() *Response {
  3302  	if !p.IsSetSuccess() {
  3303  		return RedisProxySetNXBytesResult_Success_DEFAULT
  3304  	}
  3305  	return p.Success
  3306  }
  3307  func (p *SetNXBytesResult) IsSetSuccess() bool {
  3308  	return p.Success != nil
  3309  }
  3310  
  3311  func (p *SetNXBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  3312  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3313  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3314  	}
  3315  
  3316  	for {
  3317  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3318  		if err != nil {
  3319  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3320  		}
  3321  		if fieldTypeId == thrift.STOP {
  3322  			break
  3323  		}
  3324  		switch fieldId {
  3325  		case 0:
  3326  			if fieldTypeId == thrift.STRUCT {
  3327  				if err := p.ReadField0(ctx, tp); err != nil {
  3328  					return err
  3329  				}
  3330  			} else {
  3331  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3332  					return err
  3333  				}
  3334  			}
  3335  		default:
  3336  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3337  				return err
  3338  			}
  3339  		}
  3340  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3341  			return err
  3342  		}
  3343  	}
  3344  	if err := tp.ReadStructEnd(ctx); err != nil {
  3345  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3346  	}
  3347  	return nil
  3348  }
  3349  
  3350  func (p *SetNXBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  3351  	p.Success = &Response{}
  3352  	if err := p.Success.Read(ctx, tp); err != nil {
  3353  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  3354  	}
  3355  	return nil
  3356  }
  3357  
  3358  func (p *SetNXBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  3359  	if err := tp.WriteStructBegin(ctx, "SetNXBytes_result"); err != nil {
  3360  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3361  	}
  3362  	if p != nil {
  3363  		if err := p.writeField0(ctx, tp); err != nil {
  3364  			return err
  3365  		}
  3366  	}
  3367  	if err := tp.WriteFieldStop(ctx); err != nil {
  3368  		return thrift.PrependError("write field stop error: ", err)
  3369  	}
  3370  	if err := tp.WriteStructEnd(ctx); err != nil {
  3371  		return thrift.PrependError("write struct stop error: ", err)
  3372  	}
  3373  	return nil
  3374  }
  3375  
  3376  func (p *SetNXBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  3377  	if p.IsSetSuccess() {
  3378  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  3379  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  3380  		}
  3381  		if err := p.Success.Write(ctx, tp); err != nil {
  3382  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  3383  		}
  3384  		if err := tp.WriteFieldEnd(ctx); err != nil {
  3385  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  3386  		}
  3387  	}
  3388  	return err
  3389  }
  3390  
  3391  func (p *SetNXBytesResult) String() string {
  3392  	if p == nil {
  3393  		return "<nil>"
  3394  	}
  3395  	return fmt.Sprintf("SetNXBytesResult(%+v)", *p)
  3396  }
  3397  
  3398  // Attributes:
  3399  //  - Appid
  3400  //  - Key
  3401  type GetArgs struct {
  3402  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  3403  	Key   string `thrift:"key,2" db:"key" json:"key"`
  3404  }
  3405  
  3406  func NewRedisProxyGetArgs() *GetArgs {
  3407  	return &GetArgs{}
  3408  }
  3409  
  3410  func (p *GetArgs) GetAppid() string {
  3411  	return p.Appid
  3412  }
  3413  
  3414  func (p *GetArgs) GetKey() string {
  3415  	return p.Key
  3416  }
  3417  func (p *GetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  3418  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3419  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3420  	}
  3421  
  3422  	for {
  3423  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3424  		if err != nil {
  3425  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3426  		}
  3427  		if fieldTypeId == thrift.STOP {
  3428  			break
  3429  		}
  3430  		switch fieldId {
  3431  		case 1:
  3432  			if fieldTypeId == thrift.STRING {
  3433  				if err := p.ReadField1(ctx, tp); err != nil {
  3434  					return err
  3435  				}
  3436  			} else {
  3437  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3438  					return err
  3439  				}
  3440  			}
  3441  		case 2:
  3442  			if fieldTypeId == thrift.STRING {
  3443  				if err := p.ReadField2(ctx, tp); err != nil {
  3444  					return err
  3445  				}
  3446  			} else {
  3447  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3448  					return err
  3449  				}
  3450  			}
  3451  		default:
  3452  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3453  				return err
  3454  			}
  3455  		}
  3456  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3457  			return err
  3458  		}
  3459  	}
  3460  	if err := tp.ReadStructEnd(ctx); err != nil {
  3461  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3462  	}
  3463  	return nil
  3464  }
  3465  
  3466  func (p *GetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  3467  	if v, err := tp.ReadString(ctx); err != nil {
  3468  		return thrift.PrependError("error reading field 1: ", err)
  3469  	} else {
  3470  		p.Appid = v
  3471  	}
  3472  	return nil
  3473  }
  3474  
  3475  func (p *GetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  3476  	if v, err := tp.ReadString(ctx); err != nil {
  3477  		return thrift.PrependError("error reading field 2: ", err)
  3478  	} else {
  3479  		p.Key = v
  3480  	}
  3481  	return nil
  3482  }
  3483  
  3484  func (p *GetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  3485  	if err := tp.WriteStructBegin(ctx, "Get_args"); err != nil {
  3486  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3487  	}
  3488  	if p != nil {
  3489  		if err := p.writeField1(ctx, tp); err != nil {
  3490  			return err
  3491  		}
  3492  		if err := p.writeField2(ctx, tp); err != nil {
  3493  			return err
  3494  		}
  3495  	}
  3496  	if err := tp.WriteFieldStop(ctx); err != nil {
  3497  		return thrift.PrependError("write field stop error: ", err)
  3498  	}
  3499  	if err := tp.WriteStructEnd(ctx); err != nil {
  3500  		return thrift.PrependError("write struct stop error: ", err)
  3501  	}
  3502  	return nil
  3503  }
  3504  
  3505  func (p *GetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  3506  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  3507  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  3508  	}
  3509  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  3510  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  3511  	}
  3512  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3513  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  3514  	}
  3515  	return err
  3516  }
  3517  
  3518  func (p *GetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  3519  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  3520  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  3521  	}
  3522  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  3523  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  3524  	}
  3525  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3526  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  3527  	}
  3528  	return err
  3529  }
  3530  
  3531  func (p *GetArgs) String() string {
  3532  	if p == nil {
  3533  		return "<nil>"
  3534  	}
  3535  	return fmt.Sprintf("GetArgs(%+v)", *p)
  3536  }
  3537  
  3538  // Attributes:
  3539  //  - Success
  3540  type GetResult struct {
  3541  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  3542  }
  3543  
  3544  func NewRedisProxyGetResult() *GetResult {
  3545  	return &GetResult{}
  3546  }
  3547  
  3548  var RedisProxyGetResult_Success_DEFAULT *Response
  3549  
  3550  func (p *GetResult) GetSuccess() *Response {
  3551  	if !p.IsSetSuccess() {
  3552  		return RedisProxyGetResult_Success_DEFAULT
  3553  	}
  3554  	return p.Success
  3555  }
  3556  func (p *GetResult) IsSetSuccess() bool {
  3557  	return p.Success != nil
  3558  }
  3559  
  3560  func (p *GetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  3561  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3562  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3563  	}
  3564  
  3565  	for {
  3566  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3567  		if err != nil {
  3568  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3569  		}
  3570  		if fieldTypeId == thrift.STOP {
  3571  			break
  3572  		}
  3573  		switch fieldId {
  3574  		case 0:
  3575  			if fieldTypeId == thrift.STRUCT {
  3576  				if err := p.ReadField0(ctx, tp); err != nil {
  3577  					return err
  3578  				}
  3579  			} else {
  3580  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3581  					return err
  3582  				}
  3583  			}
  3584  		default:
  3585  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3586  				return err
  3587  			}
  3588  		}
  3589  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3590  			return err
  3591  		}
  3592  	}
  3593  	if err := tp.ReadStructEnd(ctx); err != nil {
  3594  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3595  	}
  3596  	return nil
  3597  }
  3598  
  3599  func (p *GetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  3600  	p.Success = &Response{}
  3601  	if err := p.Success.Read(ctx, tp); err != nil {
  3602  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  3603  	}
  3604  	return nil
  3605  }
  3606  
  3607  func (p *GetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  3608  	if err := tp.WriteStructBegin(ctx, "Get_result"); err != nil {
  3609  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3610  	}
  3611  	if p != nil {
  3612  		if err := p.writeField0(ctx, tp); err != nil {
  3613  			return err
  3614  		}
  3615  	}
  3616  	if err := tp.WriteFieldStop(ctx); err != nil {
  3617  		return thrift.PrependError("write field stop error: ", err)
  3618  	}
  3619  	if err := tp.WriteStructEnd(ctx); err != nil {
  3620  		return thrift.PrependError("write struct stop error: ", err)
  3621  	}
  3622  	return nil
  3623  }
  3624  
  3625  func (p *GetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  3626  	if p.IsSetSuccess() {
  3627  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  3628  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  3629  		}
  3630  		if err := p.Success.Write(ctx, tp); err != nil {
  3631  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  3632  		}
  3633  		if err := tp.WriteFieldEnd(ctx); err != nil {
  3634  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  3635  		}
  3636  	}
  3637  	return err
  3638  }
  3639  
  3640  func (p *GetResult) String() string {
  3641  	if p == nil {
  3642  		return "<nil>"
  3643  	}
  3644  	return fmt.Sprintf("GetResult(%+v)", *p)
  3645  }
  3646  
  3647  // Attributes:
  3648  //  - Appid
  3649  //  - Key
  3650  type GetBytesArgs struct {
  3651  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  3652  	Key   string `thrift:"key,2" db:"key" json:"key"`
  3653  }
  3654  
  3655  func NewRedisProxyGetBytesArgs() *GetBytesArgs {
  3656  	return &GetBytesArgs{}
  3657  }
  3658  
  3659  func (p *GetBytesArgs) GetAppid() string {
  3660  	return p.Appid
  3661  }
  3662  
  3663  func (p *GetBytesArgs) GetKey() string {
  3664  	return p.Key
  3665  }
  3666  func (p *GetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  3667  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3668  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3669  	}
  3670  
  3671  	for {
  3672  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3673  		if err != nil {
  3674  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3675  		}
  3676  		if fieldTypeId == thrift.STOP {
  3677  			break
  3678  		}
  3679  		switch fieldId {
  3680  		case 1:
  3681  			if fieldTypeId == thrift.STRING {
  3682  				if err := p.ReadField1(ctx, tp); err != nil {
  3683  					return err
  3684  				}
  3685  			} else {
  3686  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3687  					return err
  3688  				}
  3689  			}
  3690  		case 2:
  3691  			if fieldTypeId == thrift.STRING {
  3692  				if err := p.ReadField2(ctx, tp); err != nil {
  3693  					return err
  3694  				}
  3695  			} else {
  3696  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3697  					return err
  3698  				}
  3699  			}
  3700  		default:
  3701  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3702  				return err
  3703  			}
  3704  		}
  3705  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3706  			return err
  3707  		}
  3708  	}
  3709  	if err := tp.ReadStructEnd(ctx); err != nil {
  3710  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3711  	}
  3712  	return nil
  3713  }
  3714  
  3715  func (p *GetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  3716  	if v, err := tp.ReadString(ctx); err != nil {
  3717  		return thrift.PrependError("error reading field 1: ", err)
  3718  	} else {
  3719  		p.Appid = v
  3720  	}
  3721  	return nil
  3722  }
  3723  
  3724  func (p *GetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  3725  	if v, err := tp.ReadString(ctx); err != nil {
  3726  		return thrift.PrependError("error reading field 2: ", err)
  3727  	} else {
  3728  		p.Key = v
  3729  	}
  3730  	return nil
  3731  }
  3732  
  3733  func (p *GetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  3734  	if err := tp.WriteStructBegin(ctx, "GetBytes_args"); err != nil {
  3735  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3736  	}
  3737  	if p != nil {
  3738  		if err := p.writeField1(ctx, tp); err != nil {
  3739  			return err
  3740  		}
  3741  		if err := p.writeField2(ctx, tp); err != nil {
  3742  			return err
  3743  		}
  3744  	}
  3745  	if err := tp.WriteFieldStop(ctx); err != nil {
  3746  		return thrift.PrependError("write field stop error: ", err)
  3747  	}
  3748  	if err := tp.WriteStructEnd(ctx); err != nil {
  3749  		return thrift.PrependError("write struct stop error: ", err)
  3750  	}
  3751  	return nil
  3752  }
  3753  
  3754  func (p *GetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  3755  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  3756  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  3757  	}
  3758  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  3759  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  3760  	}
  3761  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3762  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  3763  	}
  3764  	return err
  3765  }
  3766  
  3767  func (p *GetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  3768  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  3769  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  3770  	}
  3771  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  3772  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  3773  	}
  3774  	if err := tp.WriteFieldEnd(ctx); err != nil {
  3775  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  3776  	}
  3777  	return err
  3778  }
  3779  
  3780  func (p *GetBytesArgs) String() string {
  3781  	if p == nil {
  3782  		return "<nil>"
  3783  	}
  3784  	return fmt.Sprintf("GetBytesArgs(%+v)", *p)
  3785  }
  3786  
  3787  // Attributes:
  3788  //  - Success
  3789  type GetBytesResult struct {
  3790  	Success *BytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  3791  }
  3792  
  3793  func NewRedisProxyGetBytesResult() *GetBytesResult {
  3794  	return &GetBytesResult{}
  3795  }
  3796  
  3797  var RedisProxyGetBytesResult_Success_DEFAULT *BytesResponse
  3798  
  3799  func (p *GetBytesResult) GetSuccess() *BytesResponse {
  3800  	if !p.IsSetSuccess() {
  3801  		return RedisProxyGetBytesResult_Success_DEFAULT
  3802  	}
  3803  	return p.Success
  3804  }
  3805  func (p *GetBytesResult) IsSetSuccess() bool {
  3806  	return p.Success != nil
  3807  }
  3808  
  3809  func (p *GetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  3810  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3811  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3812  	}
  3813  
  3814  	for {
  3815  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3816  		if err != nil {
  3817  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3818  		}
  3819  		if fieldTypeId == thrift.STOP {
  3820  			break
  3821  		}
  3822  		switch fieldId {
  3823  		case 0:
  3824  			if fieldTypeId == thrift.STRUCT {
  3825  				if err := p.ReadField0(ctx, tp); err != nil {
  3826  					return err
  3827  				}
  3828  			} else {
  3829  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3830  					return err
  3831  				}
  3832  			}
  3833  		default:
  3834  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3835  				return err
  3836  			}
  3837  		}
  3838  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3839  			return err
  3840  		}
  3841  	}
  3842  	if err := tp.ReadStructEnd(ctx); err != nil {
  3843  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3844  	}
  3845  	return nil
  3846  }
  3847  
  3848  func (p *GetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  3849  	p.Success = &BytesResponse{}
  3850  	if err := p.Success.Read(ctx, tp); err != nil {
  3851  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  3852  	}
  3853  	return nil
  3854  }
  3855  
  3856  func (p *GetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  3857  	if err := tp.WriteStructBegin(ctx, "GetBytes_result"); err != nil {
  3858  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  3859  	}
  3860  	if p != nil {
  3861  		if err := p.writeField0(ctx, tp); err != nil {
  3862  			return err
  3863  		}
  3864  	}
  3865  	if err := tp.WriteFieldStop(ctx); err != nil {
  3866  		return thrift.PrependError("write field stop error: ", err)
  3867  	}
  3868  	if err := tp.WriteStructEnd(ctx); err != nil {
  3869  		return thrift.PrependError("write struct stop error: ", err)
  3870  	}
  3871  	return nil
  3872  }
  3873  
  3874  func (p *GetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  3875  	if p.IsSetSuccess() {
  3876  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  3877  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  3878  		}
  3879  		if err := p.Success.Write(ctx, tp); err != nil {
  3880  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  3881  		}
  3882  		if err := tp.WriteFieldEnd(ctx); err != nil {
  3883  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  3884  		}
  3885  	}
  3886  	return err
  3887  }
  3888  
  3889  func (p *GetBytesResult) String() string {
  3890  	if p == nil {
  3891  		return "<nil>"
  3892  	}
  3893  	return fmt.Sprintf("GetBytesResult(%+v)", *p)
  3894  }
  3895  
  3896  // Attributes:
  3897  //  - Appid
  3898  //  - Reqs
  3899  type MSetArgs struct {
  3900  	Appid string            `thrift:"appid,1" db:"appid" json:"appid"`
  3901  	Reqs  map[string]string `thrift:"reqs,2" db:"reqs" json:"reqs"`
  3902  }
  3903  
  3904  func NewRedisProxyMSetArgs() *MSetArgs {
  3905  	return &MSetArgs{}
  3906  }
  3907  
  3908  func (p *MSetArgs) GetAppid() string {
  3909  	return p.Appid
  3910  }
  3911  
  3912  func (p *MSetArgs) GetReqs() map[string]string {
  3913  	return p.Reqs
  3914  }
  3915  func (p *MSetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  3916  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  3917  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  3918  	}
  3919  
  3920  	for {
  3921  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  3922  		if err != nil {
  3923  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  3924  		}
  3925  		if fieldTypeId == thrift.STOP {
  3926  			break
  3927  		}
  3928  		switch fieldId {
  3929  		case 1:
  3930  			if fieldTypeId == thrift.STRING {
  3931  				if err := p.ReadField1(ctx, tp); err != nil {
  3932  					return err
  3933  				}
  3934  			} else {
  3935  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3936  					return err
  3937  				}
  3938  			}
  3939  		case 2:
  3940  			if fieldTypeId == thrift.MAP {
  3941  				if err := p.ReadField2(ctx, tp); err != nil {
  3942  					return err
  3943  				}
  3944  			} else {
  3945  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3946  					return err
  3947  				}
  3948  			}
  3949  		default:
  3950  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  3951  				return err
  3952  			}
  3953  		}
  3954  		if err := tp.ReadFieldEnd(ctx); err != nil {
  3955  			return err
  3956  		}
  3957  	}
  3958  	if err := tp.ReadStructEnd(ctx); err != nil {
  3959  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  3960  	}
  3961  	return nil
  3962  }
  3963  
  3964  func (p *MSetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  3965  	if v, err := tp.ReadString(ctx); err != nil {
  3966  		return thrift.PrependError("error reading field 1: ", err)
  3967  	} else {
  3968  		p.Appid = v
  3969  	}
  3970  	return nil
  3971  }
  3972  
  3973  func (p *MSetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  3974  	_, _, size, err := tp.ReadMapBegin(ctx)
  3975  	if err != nil {
  3976  		return thrift.PrependError("error reading map begin: ", err)
  3977  	}
  3978  	tMap := make(map[string]string, size)
  3979  	p.Reqs = tMap
  3980  	for i := 0; i < size; i++ {
  3981  		var _key179 string
  3982  		if v, err := tp.ReadString(ctx); err != nil {
  3983  			return thrift.PrependError("error reading field 0: ", err)
  3984  		} else {
  3985  			_key179 = v
  3986  		}
  3987  		var _val180 string
  3988  		if v, err := tp.ReadString(ctx); err != nil {
  3989  			return thrift.PrependError("error reading field 0: ", err)
  3990  		} else {
  3991  			_val180 = v
  3992  		}
  3993  		p.Reqs[_key179] = _val180
  3994  	}
  3995  	if err := tp.ReadMapEnd(ctx); err != nil {
  3996  		return thrift.PrependError("error reading map end: ", err)
  3997  	}
  3998  	return nil
  3999  }
  4000  
  4001  func (p *MSetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  4002  	if err := tp.WriteStructBegin(ctx, "MSet_args"); err != nil {
  4003  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4004  	}
  4005  	if p != nil {
  4006  		if err := p.writeField1(ctx, tp); err != nil {
  4007  			return err
  4008  		}
  4009  		if err := p.writeField2(ctx, tp); err != nil {
  4010  			return err
  4011  		}
  4012  	}
  4013  	if err := tp.WriteFieldStop(ctx); err != nil {
  4014  		return thrift.PrependError("write field stop error: ", err)
  4015  	}
  4016  	if err := tp.WriteStructEnd(ctx); err != nil {
  4017  		return thrift.PrependError("write struct stop error: ", err)
  4018  	}
  4019  	return nil
  4020  }
  4021  
  4022  func (p *MSetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  4023  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  4024  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  4025  	}
  4026  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  4027  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  4028  	}
  4029  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4030  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  4031  	}
  4032  	return err
  4033  }
  4034  
  4035  func (p *MSetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  4036  	if err := tp.WriteFieldBegin(ctx, "reqs", thrift.MAP, 2); err != nil {
  4037  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:reqs: ", p), err)
  4038  	}
  4039  	if err := tp.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.Reqs)); err != nil {
  4040  		return thrift.PrependError("error writing map begin: ", err)
  4041  	}
  4042  	for k, v := range p.Reqs {
  4043  		if err := tp.WriteString(ctx, string(k)); err != nil {
  4044  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4045  		}
  4046  		if err := tp.WriteString(ctx, string(v)); err != nil {
  4047  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4048  		}
  4049  	}
  4050  	if err := tp.WriteMapEnd(ctx); err != nil {
  4051  		return thrift.PrependError("error writing map end: ", err)
  4052  	}
  4053  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4054  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:reqs: ", p), err)
  4055  	}
  4056  	return err
  4057  }
  4058  
  4059  func (p *MSetArgs) String() string {
  4060  	if p == nil {
  4061  		return "<nil>"
  4062  	}
  4063  	return fmt.Sprintf("MSetArgs(%+v)", *p)
  4064  }
  4065  
  4066  // Attributes:
  4067  //  - Success
  4068  type MSetResult struct {
  4069  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  4070  }
  4071  
  4072  func NewRedisProxyMSetResult() *MSetResult {
  4073  	return &MSetResult{}
  4074  }
  4075  
  4076  var RedisProxyMSetResult_Success_DEFAULT *Response
  4077  
  4078  func (p *MSetResult) GetSuccess() *Response {
  4079  	if !p.IsSetSuccess() {
  4080  		return RedisProxyMSetResult_Success_DEFAULT
  4081  	}
  4082  	return p.Success
  4083  }
  4084  func (p *MSetResult) IsSetSuccess() bool {
  4085  	return p.Success != nil
  4086  }
  4087  
  4088  func (p *MSetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  4089  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4090  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4091  	}
  4092  
  4093  	for {
  4094  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4095  		if err != nil {
  4096  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4097  		}
  4098  		if fieldTypeId == thrift.STOP {
  4099  			break
  4100  		}
  4101  		switch fieldId {
  4102  		case 0:
  4103  			if fieldTypeId == thrift.STRUCT {
  4104  				if err := p.ReadField0(ctx, tp); err != nil {
  4105  					return err
  4106  				}
  4107  			} else {
  4108  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4109  					return err
  4110  				}
  4111  			}
  4112  		default:
  4113  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4114  				return err
  4115  			}
  4116  		}
  4117  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4118  			return err
  4119  		}
  4120  	}
  4121  	if err := tp.ReadStructEnd(ctx); err != nil {
  4122  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4123  	}
  4124  	return nil
  4125  }
  4126  
  4127  func (p *MSetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  4128  	p.Success = &Response{}
  4129  	if err := p.Success.Read(ctx, tp); err != nil {
  4130  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  4131  	}
  4132  	return nil
  4133  }
  4134  
  4135  func (p *MSetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  4136  	if err := tp.WriteStructBegin(ctx, "MSet_result"); err != nil {
  4137  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4138  	}
  4139  	if p != nil {
  4140  		if err := p.writeField0(ctx, tp); err != nil {
  4141  			return err
  4142  		}
  4143  	}
  4144  	if err := tp.WriteFieldStop(ctx); err != nil {
  4145  		return thrift.PrependError("write field stop error: ", err)
  4146  	}
  4147  	if err := tp.WriteStructEnd(ctx); err != nil {
  4148  		return thrift.PrependError("write struct stop error: ", err)
  4149  	}
  4150  	return nil
  4151  }
  4152  
  4153  func (p *MSetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  4154  	if p.IsSetSuccess() {
  4155  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  4156  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  4157  		}
  4158  		if err := p.Success.Write(ctx, tp); err != nil {
  4159  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  4160  		}
  4161  		if err := tp.WriteFieldEnd(ctx); err != nil {
  4162  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  4163  		}
  4164  	}
  4165  	return err
  4166  }
  4167  
  4168  func (p *MSetResult) String() string {
  4169  	if p == nil {
  4170  		return "<nil>"
  4171  	}
  4172  	return fmt.Sprintf("MSetResult(%+v)", *p)
  4173  }
  4174  
  4175  // Attributes:
  4176  //  - Appid
  4177  //  - Reqs
  4178  type RedisProxyMSetBytesArgs struct {
  4179  	Appid string            `thrift:"appid,1" db:"appid" json:"appid"`
  4180  	Reqs  map[string][]byte `thrift:"reqs,2" db:"reqs" json:"reqs"`
  4181  }
  4182  
  4183  func NewRedisProxyMSetBytesArgs() *RedisProxyMSetBytesArgs {
  4184  	return &RedisProxyMSetBytesArgs{}
  4185  }
  4186  
  4187  func (p *RedisProxyMSetBytesArgs) GetAppid() string {
  4188  	return p.Appid
  4189  }
  4190  
  4191  func (p *RedisProxyMSetBytesArgs) GetReqs() map[string][]byte {
  4192  	return p.Reqs
  4193  }
  4194  func (p *RedisProxyMSetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  4195  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4196  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4197  	}
  4198  
  4199  	for {
  4200  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4201  		if err != nil {
  4202  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4203  		}
  4204  		if fieldTypeId == thrift.STOP {
  4205  			break
  4206  		}
  4207  		switch fieldId {
  4208  		case 1:
  4209  			if fieldTypeId == thrift.STRING {
  4210  				if err := p.ReadField1(ctx, tp); err != nil {
  4211  					return err
  4212  				}
  4213  			} else {
  4214  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4215  					return err
  4216  				}
  4217  			}
  4218  		case 2:
  4219  			if fieldTypeId == thrift.MAP {
  4220  				if err := p.ReadField2(ctx, tp); err != nil {
  4221  					return err
  4222  				}
  4223  			} else {
  4224  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4225  					return err
  4226  				}
  4227  			}
  4228  		default:
  4229  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4230  				return err
  4231  			}
  4232  		}
  4233  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4234  			return err
  4235  		}
  4236  	}
  4237  	if err := tp.ReadStructEnd(ctx); err != nil {
  4238  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4239  	}
  4240  	return nil
  4241  }
  4242  
  4243  func (p *RedisProxyMSetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  4244  	if v, err := tp.ReadString(ctx); err != nil {
  4245  		return thrift.PrependError("error reading field 1: ", err)
  4246  	} else {
  4247  		p.Appid = v
  4248  	}
  4249  	return nil
  4250  }
  4251  
  4252  func (p *RedisProxyMSetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  4253  	_, _, size, err := tp.ReadMapBegin(ctx)
  4254  	if err != nil {
  4255  		return thrift.PrependError("error reading map begin: ", err)
  4256  	}
  4257  	tMap := make(map[string][]byte, size)
  4258  	p.Reqs = tMap
  4259  	for i := 0; i < size; i++ {
  4260  		var _key181 string
  4261  		if v, err := tp.ReadString(ctx); err != nil {
  4262  			return thrift.PrependError("error reading field 0: ", err)
  4263  		} else {
  4264  			_key181 = v
  4265  		}
  4266  		var _val182 []byte
  4267  		if v, err := tp.ReadBinary(ctx); err != nil {
  4268  			return thrift.PrependError("error reading field 0: ", err)
  4269  		} else {
  4270  			_val182 = v
  4271  		}
  4272  		p.Reqs[_key181] = _val182
  4273  	}
  4274  	if err := tp.ReadMapEnd(ctx); err != nil {
  4275  		return thrift.PrependError("error reading map end: ", err)
  4276  	}
  4277  	return nil
  4278  }
  4279  
  4280  func (p *RedisProxyMSetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  4281  	if err := tp.WriteStructBegin(ctx, "MSetBytes_args"); err != nil {
  4282  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4283  	}
  4284  	if p != nil {
  4285  		if err := p.writeField1(ctx, tp); err != nil {
  4286  			return err
  4287  		}
  4288  		if err := p.writeField2(ctx, tp); err != nil {
  4289  			return err
  4290  		}
  4291  	}
  4292  	if err := tp.WriteFieldStop(ctx); err != nil {
  4293  		return thrift.PrependError("write field stop error: ", err)
  4294  	}
  4295  	if err := tp.WriteStructEnd(ctx); err != nil {
  4296  		return thrift.PrependError("write struct stop error: ", err)
  4297  	}
  4298  	return nil
  4299  }
  4300  
  4301  func (p *RedisProxyMSetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  4302  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  4303  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  4304  	}
  4305  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  4306  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  4307  	}
  4308  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4309  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  4310  	}
  4311  	return err
  4312  }
  4313  
  4314  func (p *RedisProxyMSetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  4315  	if err := tp.WriteFieldBegin(ctx, "reqs", thrift.MAP, 2); err != nil {
  4316  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:reqs: ", p), err)
  4317  	}
  4318  	if err := tp.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.Reqs)); err != nil {
  4319  		return thrift.PrependError("error writing map begin: ", err)
  4320  	}
  4321  	for k, v := range p.Reqs {
  4322  		if err := tp.WriteString(ctx, string(k)); err != nil {
  4323  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4324  		}
  4325  		if err := tp.WriteBinary(ctx, v); err != nil {
  4326  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4327  		}
  4328  	}
  4329  	if err := tp.WriteMapEnd(ctx); err != nil {
  4330  		return thrift.PrependError("error writing map end: ", err)
  4331  	}
  4332  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4333  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:reqs: ", p), err)
  4334  	}
  4335  	return err
  4336  }
  4337  
  4338  func (p *RedisProxyMSetBytesArgs) String() string {
  4339  	if p == nil {
  4340  		return "<nil>"
  4341  	}
  4342  	return fmt.Sprintf("RedisProxyMSetBytesArgs(%+v)", *p)
  4343  }
  4344  
  4345  // Attributes:
  4346  //  - Success
  4347  type MSetBytesResult struct {
  4348  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  4349  }
  4350  
  4351  func NewRedisProxyMSetBytesResult() *MSetBytesResult {
  4352  	return &MSetBytesResult{}
  4353  }
  4354  
  4355  var RedisProxyMSetBytesResult_Success_DEFAULT *Response
  4356  
  4357  func (p *MSetBytesResult) GetSuccess() *Response {
  4358  	if !p.IsSetSuccess() {
  4359  		return RedisProxyMSetBytesResult_Success_DEFAULT
  4360  	}
  4361  	return p.Success
  4362  }
  4363  func (p *MSetBytesResult) IsSetSuccess() bool {
  4364  	return p.Success != nil
  4365  }
  4366  
  4367  func (p *MSetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  4368  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4369  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4370  	}
  4371  
  4372  	for {
  4373  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4374  		if err != nil {
  4375  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4376  		}
  4377  		if fieldTypeId == thrift.STOP {
  4378  			break
  4379  		}
  4380  		switch fieldId {
  4381  		case 0:
  4382  			if fieldTypeId == thrift.STRUCT {
  4383  				if err := p.ReadField0(ctx, tp); err != nil {
  4384  					return err
  4385  				}
  4386  			} else {
  4387  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4388  					return err
  4389  				}
  4390  			}
  4391  		default:
  4392  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4393  				return err
  4394  			}
  4395  		}
  4396  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4397  			return err
  4398  		}
  4399  	}
  4400  	if err := tp.ReadStructEnd(ctx); err != nil {
  4401  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4402  	}
  4403  	return nil
  4404  }
  4405  
  4406  func (p *MSetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  4407  	p.Success = &Response{}
  4408  	if err := p.Success.Read(ctx, tp); err != nil {
  4409  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  4410  	}
  4411  	return nil
  4412  }
  4413  
  4414  func (p *MSetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  4415  	if err := tp.WriteStructBegin(ctx, "MSetBytes_result"); err != nil {
  4416  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4417  	}
  4418  	if p != nil {
  4419  		if err := p.writeField0(ctx, tp); err != nil {
  4420  			return err
  4421  		}
  4422  	}
  4423  	if err := tp.WriteFieldStop(ctx); err != nil {
  4424  		return thrift.PrependError("write field stop error: ", err)
  4425  	}
  4426  	if err := tp.WriteStructEnd(ctx); err != nil {
  4427  		return thrift.PrependError("write struct stop error: ", err)
  4428  	}
  4429  	return nil
  4430  }
  4431  
  4432  func (p *MSetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  4433  	if p.IsSetSuccess() {
  4434  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  4435  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  4436  		}
  4437  		if err := p.Success.Write(ctx, tp); err != nil {
  4438  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  4439  		}
  4440  		if err := tp.WriteFieldEnd(ctx); err != nil {
  4441  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  4442  		}
  4443  	}
  4444  	return err
  4445  }
  4446  
  4447  func (p *MSetBytesResult) String() string {
  4448  	if p == nil {
  4449  		return "<nil>"
  4450  	}
  4451  	return fmt.Sprintf("MSetBytesResult(%+v)", *p)
  4452  }
  4453  
  4454  // Attributes:
  4455  //  - Appid
  4456  //  - Keys
  4457  type MGetArgs struct {
  4458  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
  4459  	Keys  []string `thrift:"keys,2" db:"keys" json:"keys"`
  4460  }
  4461  
  4462  func NewRedisProxyMGetArgs() *MGetArgs {
  4463  	return &MGetArgs{}
  4464  }
  4465  
  4466  func (p *MGetArgs) GetAppid() string {
  4467  	return p.Appid
  4468  }
  4469  
  4470  func (p *MGetArgs) GetKeys() []string {
  4471  	return p.Keys
  4472  }
  4473  func (p *MGetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  4474  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4475  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4476  	}
  4477  
  4478  	for {
  4479  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4480  		if err != nil {
  4481  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4482  		}
  4483  		if fieldTypeId == thrift.STOP {
  4484  			break
  4485  		}
  4486  		switch fieldId {
  4487  		case 1:
  4488  			if fieldTypeId == thrift.STRING {
  4489  				if err := p.ReadField1(ctx, tp); err != nil {
  4490  					return err
  4491  				}
  4492  			} else {
  4493  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4494  					return err
  4495  				}
  4496  			}
  4497  		case 2:
  4498  			if fieldTypeId == thrift.LIST {
  4499  				if err := p.ReadField2(ctx, tp); err != nil {
  4500  					return err
  4501  				}
  4502  			} else {
  4503  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4504  					return err
  4505  				}
  4506  			}
  4507  		default:
  4508  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4509  				return err
  4510  			}
  4511  		}
  4512  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4513  			return err
  4514  		}
  4515  	}
  4516  	if err := tp.ReadStructEnd(ctx); err != nil {
  4517  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4518  	}
  4519  	return nil
  4520  }
  4521  
  4522  func (p *MGetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  4523  	if v, err := tp.ReadString(ctx); err != nil {
  4524  		return thrift.PrependError("error reading field 1: ", err)
  4525  	} else {
  4526  		p.Appid = v
  4527  	}
  4528  	return nil
  4529  }
  4530  
  4531  func (p *MGetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  4532  	_, size, err := tp.ReadListBegin(ctx)
  4533  	if err != nil {
  4534  		return thrift.PrependError("error reading list begin: ", err)
  4535  	}
  4536  	tSlice := make([]string, 0, size)
  4537  	p.Keys = tSlice
  4538  	for i := 0; i < size; i++ {
  4539  		var _elem183 string
  4540  		if v, err := tp.ReadString(ctx); err != nil {
  4541  			return thrift.PrependError("error reading field 0: ", err)
  4542  		} else {
  4543  			_elem183 = v
  4544  		}
  4545  		p.Keys = append(p.Keys, _elem183)
  4546  	}
  4547  	if err := tp.ReadListEnd(ctx); err != nil {
  4548  		return thrift.PrependError("error reading list end: ", err)
  4549  	}
  4550  	return nil
  4551  }
  4552  
  4553  func (p *MGetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  4554  	if err := tp.WriteStructBegin(ctx, "MGet_args"); err != nil {
  4555  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4556  	}
  4557  	if p != nil {
  4558  		if err := p.writeField1(ctx, tp); err != nil {
  4559  			return err
  4560  		}
  4561  		if err := p.writeField2(ctx, tp); err != nil {
  4562  			return err
  4563  		}
  4564  	}
  4565  	if err := tp.WriteFieldStop(ctx); err != nil {
  4566  		return thrift.PrependError("write field stop error: ", err)
  4567  	}
  4568  	if err := tp.WriteStructEnd(ctx); err != nil {
  4569  		return thrift.PrependError("write struct stop error: ", err)
  4570  	}
  4571  	return nil
  4572  }
  4573  
  4574  func (p *MGetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  4575  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  4576  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  4577  	}
  4578  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  4579  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  4580  	}
  4581  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4582  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  4583  	}
  4584  	return err
  4585  }
  4586  
  4587  func (p *MGetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  4588  	if err := tp.WriteFieldBegin(ctx, "keys", thrift.LIST, 2); err != nil {
  4589  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:keys: ", p), err)
  4590  	}
  4591  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Keys)); err != nil {
  4592  		return thrift.PrependError("error writing list begin: ", err)
  4593  	}
  4594  	for _, v := range p.Keys {
  4595  		if err := tp.WriteString(ctx, string(v)); err != nil {
  4596  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4597  		}
  4598  	}
  4599  	if err := tp.WriteListEnd(ctx); err != nil {
  4600  		return thrift.PrependError("error writing list end: ", err)
  4601  	}
  4602  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4603  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:keys: ", p), err)
  4604  	}
  4605  	return err
  4606  }
  4607  
  4608  func (p *MGetArgs) String() string {
  4609  	if p == nil {
  4610  		return "<nil>"
  4611  	}
  4612  	return fmt.Sprintf("MGetArgs(%+v)", *p)
  4613  }
  4614  
  4615  // Attributes:
  4616  //  - Success
  4617  type MGetResult struct {
  4618  	Success *MResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  4619  }
  4620  
  4621  func NewMGetResult() *MGetResult {
  4622  	return &MGetResult{}
  4623  }
  4624  
  4625  var MGetResult_Success_DEFAULT *MResponse
  4626  
  4627  func (p *MGetResult) GetSuccess() *MResponse {
  4628  	if !p.IsSetSuccess() {
  4629  		return MGetResult_Success_DEFAULT
  4630  	}
  4631  	return p.Success
  4632  }
  4633  func (p *MGetResult) IsSetSuccess() bool {
  4634  	return p.Success != nil
  4635  }
  4636  
  4637  func (p *MGetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  4638  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4639  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4640  	}
  4641  
  4642  	for {
  4643  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4644  		if err != nil {
  4645  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4646  		}
  4647  		if fieldTypeId == thrift.STOP {
  4648  			break
  4649  		}
  4650  		switch fieldId {
  4651  		case 0:
  4652  			if fieldTypeId == thrift.STRUCT {
  4653  				if err := p.ReadField0(ctx, tp); err != nil {
  4654  					return err
  4655  				}
  4656  			} else {
  4657  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4658  					return err
  4659  				}
  4660  			}
  4661  		default:
  4662  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4663  				return err
  4664  			}
  4665  		}
  4666  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4667  			return err
  4668  		}
  4669  	}
  4670  	if err := tp.ReadStructEnd(ctx); err != nil {
  4671  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4672  	}
  4673  	return nil
  4674  }
  4675  
  4676  func (p *MGetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  4677  	p.Success = &MResponse{}
  4678  	if err := p.Success.Read(ctx, tp); err != nil {
  4679  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  4680  	}
  4681  	return nil
  4682  }
  4683  
  4684  func (p *MGetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  4685  	if err := tp.WriteStructBegin(ctx, "MGet_result"); err != nil {
  4686  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4687  	}
  4688  	if p != nil {
  4689  		if err := p.writeField0(ctx, tp); err != nil {
  4690  			return err
  4691  		}
  4692  	}
  4693  	if err := tp.WriteFieldStop(ctx); err != nil {
  4694  		return thrift.PrependError("write field stop error: ", err)
  4695  	}
  4696  	if err := tp.WriteStructEnd(ctx); err != nil {
  4697  		return thrift.PrependError("write struct stop error: ", err)
  4698  	}
  4699  	return nil
  4700  }
  4701  
  4702  func (p *MGetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  4703  	if p.IsSetSuccess() {
  4704  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  4705  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  4706  		}
  4707  		if err := p.Success.Write(ctx, tp); err != nil {
  4708  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  4709  		}
  4710  		if err := tp.WriteFieldEnd(ctx); err != nil {
  4711  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  4712  		}
  4713  	}
  4714  	return err
  4715  }
  4716  
  4717  func (p *MGetResult) String() string {
  4718  	if p == nil {
  4719  		return "<nil>"
  4720  	}
  4721  	return fmt.Sprintf("MGetResult(%+v)", *p)
  4722  }
  4723  
  4724  // Attributes:
  4725  //  - Appid
  4726  //  - Keys
  4727  type MGetBytesArgs struct {
  4728  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
  4729  	Keys  []string `thrift:"keys,2" db:"keys" json:"keys"`
  4730  }
  4731  
  4732  func NewRedisProxyMGetBytesArgs() *MGetBytesArgs {
  4733  	return &MGetBytesArgs{}
  4734  }
  4735  
  4736  func (p *MGetBytesArgs) GetAppid() string {
  4737  	return p.Appid
  4738  }
  4739  
  4740  func (p *MGetBytesArgs) GetKeys() []string {
  4741  	return p.Keys
  4742  }
  4743  func (p *MGetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  4744  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4745  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4746  	}
  4747  
  4748  	for {
  4749  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4750  		if err != nil {
  4751  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4752  		}
  4753  		if fieldTypeId == thrift.STOP {
  4754  			break
  4755  		}
  4756  		switch fieldId {
  4757  		case 1:
  4758  			if fieldTypeId == thrift.STRING {
  4759  				if err := p.ReadField1(ctx, tp); err != nil {
  4760  					return err
  4761  				}
  4762  			} else {
  4763  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4764  					return err
  4765  				}
  4766  			}
  4767  		case 2:
  4768  			if fieldTypeId == thrift.LIST {
  4769  				if err := p.ReadField2(ctx, tp); err != nil {
  4770  					return err
  4771  				}
  4772  			} else {
  4773  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4774  					return err
  4775  				}
  4776  			}
  4777  		default:
  4778  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4779  				return err
  4780  			}
  4781  		}
  4782  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4783  			return err
  4784  		}
  4785  	}
  4786  	if err := tp.ReadStructEnd(ctx); err != nil {
  4787  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4788  	}
  4789  	return nil
  4790  }
  4791  
  4792  func (p *MGetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  4793  	if v, err := tp.ReadString(ctx); err != nil {
  4794  		return thrift.PrependError("error reading field 1: ", err)
  4795  	} else {
  4796  		p.Appid = v
  4797  	}
  4798  	return nil
  4799  }
  4800  
  4801  func (p *MGetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  4802  	_, size, err := tp.ReadListBegin(ctx)
  4803  	if err != nil {
  4804  		return thrift.PrependError("error reading list begin: ", err)
  4805  	}
  4806  	tSlice := make([]string, 0, size)
  4807  	p.Keys = tSlice
  4808  	for i := 0; i < size; i++ {
  4809  		var _elem184 string
  4810  		if v, err := tp.ReadString(ctx); err != nil {
  4811  			return thrift.PrependError("error reading field 0: ", err)
  4812  		} else {
  4813  			_elem184 = v
  4814  		}
  4815  		p.Keys = append(p.Keys, _elem184)
  4816  	}
  4817  	if err := tp.ReadListEnd(ctx); err != nil {
  4818  		return thrift.PrependError("error reading list end: ", err)
  4819  	}
  4820  	return nil
  4821  }
  4822  
  4823  func (p *MGetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  4824  	if err := tp.WriteStructBegin(ctx, "MGetBytes_args"); err != nil {
  4825  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4826  	}
  4827  	if p != nil {
  4828  		if err := p.writeField1(ctx, tp); err != nil {
  4829  			return err
  4830  		}
  4831  		if err := p.writeField2(ctx, tp); err != nil {
  4832  			return err
  4833  		}
  4834  	}
  4835  	if err := tp.WriteFieldStop(ctx); err != nil {
  4836  		return thrift.PrependError("write field stop error: ", err)
  4837  	}
  4838  	if err := tp.WriteStructEnd(ctx); err != nil {
  4839  		return thrift.PrependError("write struct stop error: ", err)
  4840  	}
  4841  	return nil
  4842  }
  4843  
  4844  func (p *MGetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  4845  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  4846  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  4847  	}
  4848  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  4849  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  4850  	}
  4851  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4852  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  4853  	}
  4854  	return err
  4855  }
  4856  
  4857  func (p *MGetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  4858  	if err := tp.WriteFieldBegin(ctx, "keys", thrift.LIST, 2); err != nil {
  4859  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:keys: ", p), err)
  4860  	}
  4861  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Keys)); err != nil {
  4862  		return thrift.PrependError("error writing list begin: ", err)
  4863  	}
  4864  	for _, v := range p.Keys {
  4865  		if err := tp.WriteString(ctx, string(v)); err != nil {
  4866  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  4867  		}
  4868  	}
  4869  	if err := tp.WriteListEnd(ctx); err != nil {
  4870  		return thrift.PrependError("error writing list end: ", err)
  4871  	}
  4872  	if err := tp.WriteFieldEnd(ctx); err != nil {
  4873  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:keys: ", p), err)
  4874  	}
  4875  	return err
  4876  }
  4877  
  4878  func (p *MGetBytesArgs) String() string {
  4879  	if p == nil {
  4880  		return "<nil>"
  4881  	}
  4882  	return fmt.Sprintf("MGetBytesArgs(%+v)", *p)
  4883  }
  4884  
  4885  // Attributes:
  4886  //  - Success
  4887  type MGetBytesResult struct {
  4888  	Success *MBytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  4889  }
  4890  
  4891  func NewMGetBytesResult() *MGetBytesResult {
  4892  	return &MGetBytesResult{}
  4893  }
  4894  
  4895  var MGetBytesResult_Success_DEFAULT *MBytesResponse
  4896  
  4897  func (p *MGetBytesResult) GetSuccess() *MBytesResponse {
  4898  	if !p.IsSetSuccess() {
  4899  		return MGetBytesResult_Success_DEFAULT
  4900  	}
  4901  	return p.Success
  4902  }
  4903  
  4904  func (p *MGetBytesResult) IsSetSuccess() bool {
  4905  	return p.Success != nil
  4906  }
  4907  
  4908  func (p *MGetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  4909  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  4910  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  4911  	}
  4912  
  4913  	for {
  4914  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  4915  		if err != nil {
  4916  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  4917  		}
  4918  		if fieldTypeId == thrift.STOP {
  4919  			break
  4920  		}
  4921  		switch fieldId {
  4922  		case 0:
  4923  			if fieldTypeId == thrift.STRUCT {
  4924  				if err := p.ReadField0(ctx, tp); err != nil {
  4925  					return err
  4926  				}
  4927  			} else {
  4928  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4929  					return err
  4930  				}
  4931  			}
  4932  		default:
  4933  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  4934  				return err
  4935  			}
  4936  		}
  4937  		if err := tp.ReadFieldEnd(ctx); err != nil {
  4938  			return err
  4939  		}
  4940  	}
  4941  	if err := tp.ReadStructEnd(ctx); err != nil {
  4942  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  4943  	}
  4944  	return nil
  4945  }
  4946  
  4947  func (p *MGetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  4948  	p.Success = &MBytesResponse{}
  4949  	if err := p.Success.Read(ctx, tp); err != nil {
  4950  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  4951  	}
  4952  	return nil
  4953  }
  4954  
  4955  func (p *MGetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  4956  	if err := tp.WriteStructBegin(ctx, "MGetBytes_result"); err != nil {
  4957  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  4958  	}
  4959  	if p != nil {
  4960  		if err := p.writeField0(ctx, tp); err != nil {
  4961  			return err
  4962  		}
  4963  	}
  4964  	if err := tp.WriteFieldStop(ctx); err != nil {
  4965  		return thrift.PrependError("write field stop error: ", err)
  4966  	}
  4967  	if err := tp.WriteStructEnd(ctx); err != nil {
  4968  		return thrift.PrependError("write struct stop error: ", err)
  4969  	}
  4970  	return nil
  4971  }
  4972  
  4973  func (p *MGetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  4974  	if p.IsSetSuccess() {
  4975  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  4976  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  4977  		}
  4978  		if err := p.Success.Write(ctx, tp); err != nil {
  4979  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  4980  		}
  4981  		if err := tp.WriteFieldEnd(ctx); err != nil {
  4982  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  4983  		}
  4984  	}
  4985  	return err
  4986  }
  4987  
  4988  func (p *MGetBytesResult) String() string {
  4989  	if p == nil {
  4990  		return "<nil>"
  4991  	}
  4992  	return fmt.Sprintf("MGetBytesResult(%+v)", *p)
  4993  }
  4994  
  4995  // Attributes:
  4996  //  - Appid
  4997  //  - Key
  4998  type DelArgs struct {
  4999  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  5000  	Key   string `thrift:"key,2" db:"key" json:"key"`
  5001  }
  5002  
  5003  func NewDelArgs() *DelArgs {
  5004  	return &DelArgs{}
  5005  }
  5006  
  5007  func (p *DelArgs) GetAppid() string {
  5008  	return p.Appid
  5009  }
  5010  
  5011  func (p *DelArgs) GetKey() string {
  5012  	return p.Key
  5013  }
  5014  
  5015  func (p *DelArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  5016  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5017  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5018  	}
  5019  
  5020  	for {
  5021  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5022  		if err != nil {
  5023  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5024  		}
  5025  		if fieldTypeId == thrift.STOP {
  5026  			break
  5027  		}
  5028  		switch fieldId {
  5029  		case 1:
  5030  			if fieldTypeId == thrift.STRING {
  5031  				if err := p.ReadField1(ctx, tp); err != nil {
  5032  					return err
  5033  				}
  5034  			} else {
  5035  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5036  					return err
  5037  				}
  5038  			}
  5039  		case 2:
  5040  			if fieldTypeId == thrift.STRING {
  5041  				if err := p.ReadField2(ctx, tp); err != nil {
  5042  					return err
  5043  				}
  5044  			} else {
  5045  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5046  					return err
  5047  				}
  5048  			}
  5049  		default:
  5050  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5051  				return err
  5052  			}
  5053  		}
  5054  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5055  			return err
  5056  		}
  5057  	}
  5058  	if err := tp.ReadStructEnd(ctx); err != nil {
  5059  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5060  	}
  5061  	return nil
  5062  }
  5063  
  5064  func (p *DelArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  5065  	if v, err := tp.ReadString(ctx); err != nil {
  5066  		return thrift.PrependError("error reading field 1: ", err)
  5067  	} else {
  5068  		p.Appid = v
  5069  	}
  5070  	return nil
  5071  }
  5072  
  5073  func (p *DelArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  5074  	if v, err := tp.ReadString(ctx); err != nil {
  5075  		return thrift.PrependError("error reading field 2: ", err)
  5076  	} else {
  5077  		p.Key = v
  5078  	}
  5079  	return nil
  5080  }
  5081  
  5082  func (p *DelArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  5083  	if err := tp.WriteStructBegin(ctx, "Del_args"); err != nil {
  5084  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5085  	}
  5086  	if p != nil {
  5087  		if err := p.writeField1(ctx, tp); err != nil {
  5088  			return err
  5089  		}
  5090  		if err := p.writeField2(ctx, tp); err != nil {
  5091  			return err
  5092  		}
  5093  	}
  5094  	if err := tp.WriteFieldStop(ctx); err != nil {
  5095  		return thrift.PrependError("write field stop error: ", err)
  5096  	}
  5097  	if err := tp.WriteStructEnd(ctx); err != nil {
  5098  		return thrift.PrependError("write struct stop error: ", err)
  5099  	}
  5100  	return nil
  5101  }
  5102  
  5103  func (p *DelArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  5104  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  5105  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  5106  	}
  5107  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  5108  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  5109  	}
  5110  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5111  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  5112  	}
  5113  	return err
  5114  }
  5115  
  5116  func (p *DelArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  5117  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  5118  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  5119  	}
  5120  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  5121  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  5122  	}
  5123  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5124  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  5125  	}
  5126  	return err
  5127  }
  5128  
  5129  func (p *DelArgs) String() string {
  5130  	if p == nil {
  5131  		return "<nil>"
  5132  	}
  5133  	return fmt.Sprintf("DelArgs(%+v)", *p)
  5134  }
  5135  
  5136  // Attributes:
  5137  //  - Success
  5138  type DelResult struct {
  5139  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  5140  }
  5141  
  5142  func NewDelResult() *DelResult {
  5143  	return &DelResult{}
  5144  }
  5145  
  5146  var DelResult_Success_DEFAULT *IntResponse
  5147  
  5148  func (p *DelResult) GetSuccess() *IntResponse {
  5149  	if !p.IsSetSuccess() {
  5150  		return DelResult_Success_DEFAULT
  5151  	}
  5152  	return p.Success
  5153  }
  5154  func (p *DelResult) IsSetSuccess() bool {
  5155  	return p.Success != nil
  5156  }
  5157  
  5158  func (p *DelResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  5159  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5160  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5161  	}
  5162  
  5163  	for {
  5164  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5165  		if err != nil {
  5166  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5167  		}
  5168  		if fieldTypeId == thrift.STOP {
  5169  			break
  5170  		}
  5171  		switch fieldId {
  5172  		case 0:
  5173  			if fieldTypeId == thrift.STRUCT {
  5174  				if err := p.ReadField0(ctx, tp); err != nil {
  5175  					return err
  5176  				}
  5177  			} else {
  5178  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5179  					return err
  5180  				}
  5181  			}
  5182  		default:
  5183  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5184  				return err
  5185  			}
  5186  		}
  5187  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5188  			return err
  5189  		}
  5190  	}
  5191  	if err := tp.ReadStructEnd(ctx); err != nil {
  5192  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5193  	}
  5194  	return nil
  5195  }
  5196  
  5197  func (p *DelResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  5198  	p.Success = &IntResponse{}
  5199  	if err := p.Success.Read(ctx, tp); err != nil {
  5200  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  5201  	}
  5202  	return nil
  5203  }
  5204  
  5205  func (p *DelResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  5206  	if err := tp.WriteStructBegin(ctx, "Del_result"); err != nil {
  5207  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5208  	}
  5209  	if p != nil {
  5210  		if err := p.writeField0(ctx, tp); err != nil {
  5211  			return err
  5212  		}
  5213  	}
  5214  	if err := tp.WriteFieldStop(ctx); err != nil {
  5215  		return thrift.PrependError("write field stop error: ", err)
  5216  	}
  5217  	if err := tp.WriteStructEnd(ctx); err != nil {
  5218  		return thrift.PrependError("write struct stop error: ", err)
  5219  	}
  5220  	return nil
  5221  }
  5222  
  5223  func (p *DelResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  5224  	if p.IsSetSuccess() {
  5225  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  5226  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  5227  		}
  5228  		if err := p.Success.Write(ctx, tp); err != nil {
  5229  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  5230  		}
  5231  		if err := tp.WriteFieldEnd(ctx); err != nil {
  5232  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  5233  		}
  5234  	}
  5235  	return err
  5236  }
  5237  
  5238  func (p *DelResult) String() string {
  5239  	if p == nil {
  5240  		return "<nil>"
  5241  	}
  5242  	return fmt.Sprintf("DelResult(%+v)", *p)
  5243  }
  5244  
  5245  // Attributes:
  5246  //  - Appid
  5247  //  - Keys
  5248  type MDelArgs struct {
  5249  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
  5250  	Keys  []string `thrift:"keys,2" db:"keys" json:"keys"`
  5251  }
  5252  
  5253  func NewMDelArgs() *MDelArgs {
  5254  	return &MDelArgs{}
  5255  }
  5256  
  5257  func (p *MDelArgs) GetAppid() string {
  5258  	return p.Appid
  5259  }
  5260  
  5261  func (p *MDelArgs) GetKeys() []string {
  5262  	return p.Keys
  5263  }
  5264  func (p *MDelArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  5265  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5266  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5267  	}
  5268  
  5269  	for {
  5270  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5271  		if err != nil {
  5272  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5273  		}
  5274  		if fieldTypeId == thrift.STOP {
  5275  			break
  5276  		}
  5277  		switch fieldId {
  5278  		case 1:
  5279  			if fieldTypeId == thrift.STRING {
  5280  				if err := p.ReadField1(ctx, tp); err != nil {
  5281  					return err
  5282  				}
  5283  			} else {
  5284  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5285  					return err
  5286  				}
  5287  			}
  5288  		case 2:
  5289  			if fieldTypeId == thrift.LIST {
  5290  				if err := p.ReadField2(ctx, tp); err != nil {
  5291  					return err
  5292  				}
  5293  			} else {
  5294  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5295  					return err
  5296  				}
  5297  			}
  5298  		default:
  5299  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5300  				return err
  5301  			}
  5302  		}
  5303  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5304  			return err
  5305  		}
  5306  	}
  5307  	if err := tp.ReadStructEnd(ctx); err != nil {
  5308  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5309  	}
  5310  	return nil
  5311  }
  5312  
  5313  func (p *MDelArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  5314  	if v, err := tp.ReadString(ctx); err != nil {
  5315  		return thrift.PrependError("error reading field 1: ", err)
  5316  	} else {
  5317  		p.Appid = v
  5318  	}
  5319  	return nil
  5320  }
  5321  
  5322  func (p *MDelArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  5323  	_, size, err := tp.ReadListBegin(ctx)
  5324  	if err != nil {
  5325  		return thrift.PrependError("error reading list begin: ", err)
  5326  	}
  5327  	tSlice := make([]string, 0, size)
  5328  	p.Keys = tSlice
  5329  	for i := 0; i < size; i++ {
  5330  		var _elem185 string
  5331  		if v, err := tp.ReadString(ctx); err != nil {
  5332  			return thrift.PrependError("error reading field 0: ", err)
  5333  		} else {
  5334  			_elem185 = v
  5335  		}
  5336  		p.Keys = append(p.Keys, _elem185)
  5337  	}
  5338  	if err := tp.ReadListEnd(ctx); err != nil {
  5339  		return thrift.PrependError("error reading list end: ", err)
  5340  	}
  5341  	return nil
  5342  }
  5343  
  5344  func (p *MDelArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  5345  	if err := tp.WriteStructBegin(ctx, "MDel_args"); err != nil {
  5346  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5347  	}
  5348  	if p != nil {
  5349  		if err := p.writeField1(ctx, tp); err != nil {
  5350  			return err
  5351  		}
  5352  		if err := p.writeField2(ctx, tp); err != nil {
  5353  			return err
  5354  		}
  5355  	}
  5356  	if err := tp.WriteFieldStop(ctx); err != nil {
  5357  		return thrift.PrependError("write field stop error: ", err)
  5358  	}
  5359  	if err := tp.WriteStructEnd(ctx); err != nil {
  5360  		return thrift.PrependError("write struct stop error: ", err)
  5361  	}
  5362  	return nil
  5363  }
  5364  
  5365  func (p *MDelArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  5366  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  5367  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  5368  	}
  5369  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  5370  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  5371  	}
  5372  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5373  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  5374  	}
  5375  	return err
  5376  }
  5377  
  5378  func (p *MDelArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  5379  	if err := tp.WriteFieldBegin(ctx, "keys", thrift.LIST, 2); err != nil {
  5380  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:keys: ", p), err)
  5381  	}
  5382  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Keys)); err != nil {
  5383  		return thrift.PrependError("error writing list begin: ", err)
  5384  	}
  5385  	for _, v := range p.Keys {
  5386  		if err := tp.WriteString(ctx, string(v)); err != nil {
  5387  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  5388  		}
  5389  	}
  5390  	if err := tp.WriteListEnd(ctx); err != nil {
  5391  		return thrift.PrependError("error writing list end: ", err)
  5392  	}
  5393  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5394  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:keys: ", p), err)
  5395  	}
  5396  	return err
  5397  }
  5398  
  5399  func (p *MDelArgs) String() string {
  5400  	if p == nil {
  5401  		return "<nil>"
  5402  	}
  5403  	return fmt.Sprintf("MDelArgs(%+v)", *p)
  5404  }
  5405  
  5406  // Attributes:
  5407  //  - Success
  5408  type MDelResult struct {
  5409  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  5410  }
  5411  
  5412  func NewMDelResult() *MDelResult {
  5413  	return &MDelResult{}
  5414  }
  5415  
  5416  var MDelResult_Success_DEFAULT *IntResponse
  5417  
  5418  func (p *MDelResult) GetSuccess() *IntResponse {
  5419  	if !p.IsSetSuccess() {
  5420  		return MDelResult_Success_DEFAULT
  5421  	}
  5422  	return p.Success
  5423  }
  5424  
  5425  func (p *MDelResult) IsSetSuccess() bool {
  5426  	return p.Success != nil
  5427  }
  5428  
  5429  func (p *MDelResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  5430  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5431  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5432  	}
  5433  
  5434  	for {
  5435  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5436  		if err != nil {
  5437  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5438  		}
  5439  		if fieldTypeId == thrift.STOP {
  5440  			break
  5441  		}
  5442  		switch fieldId {
  5443  		case 0:
  5444  			if fieldTypeId == thrift.STRUCT {
  5445  				if err := p.ReadField0(ctx, tp); err != nil {
  5446  					return err
  5447  				}
  5448  			} else {
  5449  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5450  					return err
  5451  				}
  5452  			}
  5453  		default:
  5454  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5455  				return err
  5456  			}
  5457  		}
  5458  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5459  			return err
  5460  		}
  5461  	}
  5462  	if err := tp.ReadStructEnd(ctx); err != nil {
  5463  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5464  	}
  5465  	return nil
  5466  }
  5467  
  5468  func (p *MDelResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  5469  	p.Success = &IntResponse{}
  5470  	if err := p.Success.Read(ctx, tp); err != nil {
  5471  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  5472  	}
  5473  	return nil
  5474  }
  5475  
  5476  func (p *MDelResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  5477  	if err := tp.WriteStructBegin(ctx, "MDel_result"); err != nil {
  5478  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5479  	}
  5480  	if p != nil {
  5481  		if err := p.writeField0(ctx, tp); err != nil {
  5482  			return err
  5483  		}
  5484  	}
  5485  	if err := tp.WriteFieldStop(ctx); err != nil {
  5486  		return thrift.PrependError("write field stop error: ", err)
  5487  	}
  5488  	if err := tp.WriteStructEnd(ctx); err != nil {
  5489  		return thrift.PrependError("write struct stop error: ", err)
  5490  	}
  5491  	return nil
  5492  }
  5493  
  5494  func (p *MDelResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  5495  	if p.IsSetSuccess() {
  5496  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  5497  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  5498  		}
  5499  		if err := p.Success.Write(ctx, tp); err != nil {
  5500  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  5501  		}
  5502  		if err := tp.WriteFieldEnd(ctx); err != nil {
  5503  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  5504  		}
  5505  	}
  5506  	return err
  5507  }
  5508  
  5509  func (p *MDelResult) String() string {
  5510  	if p == nil {
  5511  		return "<nil>"
  5512  	}
  5513  	return fmt.Sprintf("MDelResult(%+v)", *p)
  5514  }
  5515  
  5516  // Attributes:
  5517  //  - Appid
  5518  //  - Key
  5519  type KeysArgs struct {
  5520  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  5521  	Key   string `thrift:"key,2" db:"key" json:"key"`
  5522  }
  5523  
  5524  func NewKeysArgs() *KeysArgs {
  5525  	return &KeysArgs{}
  5526  }
  5527  
  5528  func (p *KeysArgs) GetAppid() string {
  5529  	return p.Appid
  5530  }
  5531  
  5532  func (p *KeysArgs) GetKey() string {
  5533  	return p.Key
  5534  }
  5535  
  5536  func (p *KeysArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  5537  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5538  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5539  	}
  5540  
  5541  	for {
  5542  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5543  		if err != nil {
  5544  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5545  		}
  5546  		if fieldTypeId == thrift.STOP {
  5547  			break
  5548  		}
  5549  		switch fieldId {
  5550  		case 1:
  5551  			if fieldTypeId == thrift.STRING {
  5552  				if err := p.ReadField1(ctx, tp); err != nil {
  5553  					return err
  5554  				}
  5555  			} else {
  5556  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5557  					return err
  5558  				}
  5559  			}
  5560  		case 2:
  5561  			if fieldTypeId == thrift.STRING {
  5562  				if err := p.ReadField2(ctx, tp); err != nil {
  5563  					return err
  5564  				}
  5565  			} else {
  5566  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5567  					return err
  5568  				}
  5569  			}
  5570  		default:
  5571  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5572  				return err
  5573  			}
  5574  		}
  5575  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5576  			return err
  5577  		}
  5578  	}
  5579  	if err := tp.ReadStructEnd(ctx); err != nil {
  5580  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5581  	}
  5582  	return nil
  5583  }
  5584  
  5585  func (p *KeysArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  5586  	if v, err := tp.ReadString(ctx); err != nil {
  5587  		return thrift.PrependError("error reading field 1: ", err)
  5588  	} else {
  5589  		p.Appid = v
  5590  	}
  5591  	return nil
  5592  }
  5593  
  5594  func (p *KeysArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  5595  	if v, err := tp.ReadString(ctx); err != nil {
  5596  		return thrift.PrependError("error reading field 2: ", err)
  5597  	} else {
  5598  		p.Key = v
  5599  	}
  5600  	return nil
  5601  }
  5602  
  5603  func (p *KeysArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  5604  	if err := tp.WriteStructBegin(ctx, "Keys_args"); err != nil {
  5605  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5606  	}
  5607  	if p != nil {
  5608  		if err := p.writeField1(ctx, tp); err != nil {
  5609  			return err
  5610  		}
  5611  		if err := p.writeField2(ctx, tp); err != nil {
  5612  			return err
  5613  		}
  5614  	}
  5615  	if err := tp.WriteFieldStop(ctx); err != nil {
  5616  		return thrift.PrependError("write field stop error: ", err)
  5617  	}
  5618  	if err := tp.WriteStructEnd(ctx); err != nil {
  5619  		return thrift.PrependError("write struct stop error: ", err)
  5620  	}
  5621  	return nil
  5622  }
  5623  
  5624  func (p *KeysArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  5625  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  5626  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  5627  	}
  5628  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  5629  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  5630  	}
  5631  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5632  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  5633  	}
  5634  	return err
  5635  }
  5636  
  5637  func (p *KeysArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  5638  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  5639  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  5640  	}
  5641  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  5642  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  5643  	}
  5644  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5645  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  5646  	}
  5647  	return err
  5648  }
  5649  
  5650  func (p *KeysArgs) String() string {
  5651  	if p == nil {
  5652  		return "<nil>"
  5653  	}
  5654  	return fmt.Sprintf("KeysArgs(%+v)", *p)
  5655  }
  5656  
  5657  // Attributes:
  5658  //  - Success
  5659  type KeysResult struct {
  5660  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  5661  }
  5662  
  5663  func NewKeysResult() *KeysResult {
  5664  	return &KeysResult{}
  5665  }
  5666  
  5667  var KeysResult_Success_DEFAULT *LResponse
  5668  
  5669  func (p *KeysResult) GetSuccess() *LResponse {
  5670  	if !p.IsSetSuccess() {
  5671  		return KeysResult_Success_DEFAULT
  5672  	}
  5673  	return p.Success
  5674  }
  5675  
  5676  func (p *KeysResult) IsSetSuccess() bool {
  5677  	return p.Success != nil
  5678  }
  5679  
  5680  func (p *KeysResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  5681  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5682  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5683  	}
  5684  
  5685  	for {
  5686  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5687  		if err != nil {
  5688  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5689  		}
  5690  		if fieldTypeId == thrift.STOP {
  5691  			break
  5692  		}
  5693  		switch fieldId {
  5694  		case 0:
  5695  			if fieldTypeId == thrift.STRUCT {
  5696  				if err := p.ReadField0(ctx, tp); err != nil {
  5697  					return err
  5698  				}
  5699  			} else {
  5700  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5701  					return err
  5702  				}
  5703  			}
  5704  		default:
  5705  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5706  				return err
  5707  			}
  5708  		}
  5709  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5710  			return err
  5711  		}
  5712  	}
  5713  	if err := tp.ReadStructEnd(ctx); err != nil {
  5714  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5715  	}
  5716  	return nil
  5717  }
  5718  
  5719  func (p *KeysResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  5720  	p.Success = &LResponse{}
  5721  	if err := p.Success.Read(ctx, tp); err != nil {
  5722  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  5723  	}
  5724  	return nil
  5725  }
  5726  
  5727  func (p *KeysResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  5728  	if err := tp.WriteStructBegin(ctx, "Keys_result"); err != nil {
  5729  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5730  	}
  5731  	if p != nil {
  5732  		if err := p.writeField0(ctx, tp); err != nil {
  5733  			return err
  5734  		}
  5735  	}
  5736  	if err := tp.WriteFieldStop(ctx); err != nil {
  5737  		return thrift.PrependError("write field stop error: ", err)
  5738  	}
  5739  	if err := tp.WriteStructEnd(ctx); err != nil {
  5740  		return thrift.PrependError("write struct stop error: ", err)
  5741  	}
  5742  	return nil
  5743  }
  5744  
  5745  func (p *KeysResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  5746  	if p.IsSetSuccess() {
  5747  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  5748  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  5749  		}
  5750  		if err := p.Success.Write(ctx, tp); err != nil {
  5751  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  5752  		}
  5753  		if err := tp.WriteFieldEnd(ctx); err != nil {
  5754  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  5755  		}
  5756  	}
  5757  	return err
  5758  }
  5759  
  5760  func (p *KeysResult) String() string {
  5761  	if p == nil {
  5762  		return "<nil>"
  5763  	}
  5764  	return fmt.Sprintf("KeysResult(%+v)", *p)
  5765  }
  5766  
  5767  // Attributes:
  5768  //  - Appid
  5769  //  - Key
  5770  //  - TTL
  5771  type ExpireArgs struct {
  5772  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  5773  	Key   string `thrift:"key,2" db:"key" json:"key"`
  5774  	TTL   int64  `thrift:"ttl,3" db:"ttl" json:"ttl"`
  5775  }
  5776  
  5777  func NewExpireArgs() *ExpireArgs {
  5778  	return &ExpireArgs{}
  5779  }
  5780  
  5781  func (p *ExpireArgs) GetAppid() string {
  5782  	return p.Appid
  5783  }
  5784  
  5785  func (p *ExpireArgs) GetKey() string {
  5786  	return p.Key
  5787  }
  5788  
  5789  func (p *ExpireArgs) GetTTL() int64 {
  5790  	return p.TTL
  5791  }
  5792  
  5793  func (p *ExpireArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  5794  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5795  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5796  	}
  5797  
  5798  	for {
  5799  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5800  		if err != nil {
  5801  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5802  		}
  5803  		if fieldTypeId == thrift.STOP {
  5804  			break
  5805  		}
  5806  		switch fieldId {
  5807  		case 1:
  5808  			if fieldTypeId == thrift.STRING {
  5809  				if err := p.ReadField1(ctx, tp); err != nil {
  5810  					return err
  5811  				}
  5812  			} else {
  5813  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5814  					return err
  5815  				}
  5816  			}
  5817  		case 2:
  5818  			if fieldTypeId == thrift.STRING {
  5819  				if err := p.ReadField2(ctx, tp); err != nil {
  5820  					return err
  5821  				}
  5822  			} else {
  5823  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5824  					return err
  5825  				}
  5826  			}
  5827  		case 3:
  5828  			if fieldTypeId == thrift.I64 {
  5829  				if err := p.ReadField3(ctx, tp); err != nil {
  5830  					return err
  5831  				}
  5832  			} else {
  5833  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5834  					return err
  5835  				}
  5836  			}
  5837  		default:
  5838  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5839  				return err
  5840  			}
  5841  		}
  5842  		if err := tp.ReadFieldEnd(ctx); err != nil {
  5843  			return err
  5844  		}
  5845  	}
  5846  	if err := tp.ReadStructEnd(ctx); err != nil {
  5847  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  5848  	}
  5849  	return nil
  5850  }
  5851  
  5852  func (p *ExpireArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  5853  	if v, err := tp.ReadString(ctx); err != nil {
  5854  		return thrift.PrependError("error reading field 1: ", err)
  5855  	} else {
  5856  		p.Appid = v
  5857  	}
  5858  	return nil
  5859  }
  5860  
  5861  func (p *ExpireArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  5862  	if v, err := tp.ReadString(ctx); err != nil {
  5863  		return thrift.PrependError("error reading field 2: ", err)
  5864  	} else {
  5865  		p.Key = v
  5866  	}
  5867  	return nil
  5868  }
  5869  
  5870  func (p *ExpireArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  5871  	if v, err := tp.ReadI64(ctx); err != nil {
  5872  		return thrift.PrependError("error reading field 3: ", err)
  5873  	} else {
  5874  		p.TTL = v
  5875  	}
  5876  	return nil
  5877  }
  5878  
  5879  func (p *ExpireArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  5880  	if err := tp.WriteStructBegin(ctx, "Expire_args"); err != nil {
  5881  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  5882  	}
  5883  	if p != nil {
  5884  		if err := p.writeField1(ctx, tp); err != nil {
  5885  			return err
  5886  		}
  5887  		if err := p.writeField2(ctx, tp); err != nil {
  5888  			return err
  5889  		}
  5890  		if err := p.writeField3(ctx, tp); err != nil {
  5891  			return err
  5892  		}
  5893  	}
  5894  	if err := tp.WriteFieldStop(ctx); err != nil {
  5895  		return thrift.PrependError("write field stop error: ", err)
  5896  	}
  5897  	if err := tp.WriteStructEnd(ctx); err != nil {
  5898  		return thrift.PrependError("write struct stop error: ", err)
  5899  	}
  5900  	return nil
  5901  }
  5902  
  5903  func (p *ExpireArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  5904  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  5905  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  5906  	}
  5907  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  5908  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  5909  	}
  5910  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5911  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  5912  	}
  5913  	return err
  5914  }
  5915  
  5916  func (p *ExpireArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  5917  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  5918  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  5919  	}
  5920  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  5921  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  5922  	}
  5923  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5924  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  5925  	}
  5926  	return err
  5927  }
  5928  
  5929  func (p *ExpireArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  5930  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 3); err != nil {
  5931  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:ttl: ", p), err)
  5932  	}
  5933  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
  5934  		return thrift.PrependError(fmt.Sprintf("%T.ttl (3) field write error: ", p), err)
  5935  	}
  5936  	if err := tp.WriteFieldEnd(ctx); err != nil {
  5937  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:ttl: ", p), err)
  5938  	}
  5939  	return err
  5940  }
  5941  
  5942  func (p *ExpireArgs) String() string {
  5943  	if p == nil {
  5944  		return "<nil>"
  5945  	}
  5946  	return fmt.Sprintf("ExpireArgs(%+v)", *p)
  5947  }
  5948  
  5949  // Attributes:
  5950  //  - Success
  5951  type ExpireResult struct {
  5952  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  5953  }
  5954  
  5955  func NewExpireResult() *ExpireResult {
  5956  	return &ExpireResult{}
  5957  }
  5958  
  5959  var ExpireResult_Success_DEFAULT *Response
  5960  
  5961  func (p *ExpireResult) GetSuccess() *Response {
  5962  	if !p.IsSetSuccess() {
  5963  		return ExpireResult_Success_DEFAULT
  5964  	}
  5965  	return p.Success
  5966  }
  5967  func (p *ExpireResult) IsSetSuccess() bool {
  5968  	return p.Success != nil
  5969  }
  5970  
  5971  func (p *ExpireResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  5972  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  5973  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  5974  	}
  5975  
  5976  	for {
  5977  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  5978  		if err != nil {
  5979  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  5980  		}
  5981  		if fieldTypeId == thrift.STOP {
  5982  			break
  5983  		}
  5984  		switch fieldId {
  5985  		case 0:
  5986  			if fieldTypeId == thrift.STRUCT {
  5987  				if err := p.ReadField0(ctx, tp); err != nil {
  5988  					return err
  5989  				}
  5990  			} else {
  5991  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5992  					return err
  5993  				}
  5994  			}
  5995  		default:
  5996  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  5997  				return err
  5998  			}
  5999  		}
  6000  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6001  			return err
  6002  		}
  6003  	}
  6004  	if err := tp.ReadStructEnd(ctx); err != nil {
  6005  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6006  	}
  6007  	return nil
  6008  }
  6009  
  6010  func (p *ExpireResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  6011  	p.Success = &Response{}
  6012  	if err := p.Success.Read(ctx, tp); err != nil {
  6013  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  6014  	}
  6015  	return nil
  6016  }
  6017  
  6018  func (p *ExpireResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  6019  	if err := tp.WriteStructBegin(ctx, "Expire_result"); err != nil {
  6020  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6021  	}
  6022  	if p != nil {
  6023  		if err := p.writeField0(ctx, tp); err != nil {
  6024  			return err
  6025  		}
  6026  	}
  6027  	if err := tp.WriteFieldStop(ctx); err != nil {
  6028  		return thrift.PrependError("write field stop error: ", err)
  6029  	}
  6030  	if err := tp.WriteStructEnd(ctx); err != nil {
  6031  		return thrift.PrependError("write struct stop error: ", err)
  6032  	}
  6033  	return nil
  6034  }
  6035  
  6036  func (p *ExpireResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  6037  	if p.IsSetSuccess() {
  6038  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  6039  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  6040  		}
  6041  		if err := p.Success.Write(ctx, tp); err != nil {
  6042  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  6043  		}
  6044  		if err := tp.WriteFieldEnd(ctx); err != nil {
  6045  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  6046  		}
  6047  	}
  6048  	return err
  6049  }
  6050  
  6051  func (p *ExpireResult) String() string {
  6052  	if p == nil {
  6053  		return "<nil>"
  6054  	}
  6055  	return fmt.Sprintf("ExpireResult(%+v)", *p)
  6056  }
  6057  
  6058  // Attributes:
  6059  //  - Appid
  6060  //  - Key
  6061  type TtlArgs struct {
  6062  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  6063  	Key   string `thrift:"key,2" db:"key" json:"key"`
  6064  }
  6065  
  6066  func NewTTLArgs() *TtlArgs {
  6067  	return &TtlArgs{}
  6068  }
  6069  
  6070  func (p *TtlArgs) GetAppid() string {
  6071  	return p.Appid
  6072  }
  6073  
  6074  func (p *TtlArgs) GetKey() string {
  6075  	return p.Key
  6076  }
  6077  func (p *TtlArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  6078  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6079  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6080  	}
  6081  
  6082  	for {
  6083  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6084  		if err != nil {
  6085  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6086  		}
  6087  		if fieldTypeId == thrift.STOP {
  6088  			break
  6089  		}
  6090  		switch fieldId {
  6091  		case 1:
  6092  			if fieldTypeId == thrift.STRING {
  6093  				if err := p.ReadField1(ctx, tp); err != nil {
  6094  					return err
  6095  				}
  6096  			} else {
  6097  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6098  					return err
  6099  				}
  6100  			}
  6101  		case 2:
  6102  			if fieldTypeId == thrift.STRING {
  6103  				if err := p.ReadField2(ctx, tp); err != nil {
  6104  					return err
  6105  				}
  6106  			} else {
  6107  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6108  					return err
  6109  				}
  6110  			}
  6111  		default:
  6112  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6113  				return err
  6114  			}
  6115  		}
  6116  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6117  			return err
  6118  		}
  6119  	}
  6120  	if err := tp.ReadStructEnd(ctx); err != nil {
  6121  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6122  	}
  6123  	return nil
  6124  }
  6125  
  6126  func (p *TtlArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  6127  	if v, err := tp.ReadString(ctx); err != nil {
  6128  		return thrift.PrependError("error reading field 1: ", err)
  6129  	} else {
  6130  		p.Appid = v
  6131  	}
  6132  	return nil
  6133  }
  6134  
  6135  func (p *TtlArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  6136  	if v, err := tp.ReadString(ctx); err != nil {
  6137  		return thrift.PrependError("error reading field 2: ", err)
  6138  	} else {
  6139  		p.Key = v
  6140  	}
  6141  	return nil
  6142  }
  6143  
  6144  func (p *TtlArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  6145  	if err := tp.WriteStructBegin(ctx, "TTL_args"); err != nil {
  6146  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6147  	}
  6148  	if p != nil {
  6149  		if err := p.writeField1(ctx, tp); err != nil {
  6150  			return err
  6151  		}
  6152  		if err := p.writeField2(ctx, tp); err != nil {
  6153  			return err
  6154  		}
  6155  	}
  6156  	if err := tp.WriteFieldStop(ctx); err != nil {
  6157  		return thrift.PrependError("write field stop error: ", err)
  6158  	}
  6159  	if err := tp.WriteStructEnd(ctx); err != nil {
  6160  		return thrift.PrependError("write struct stop error: ", err)
  6161  	}
  6162  	return nil
  6163  }
  6164  
  6165  func (p *TtlArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  6166  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  6167  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  6168  	}
  6169  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  6170  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  6171  	}
  6172  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6173  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  6174  	}
  6175  	return err
  6176  }
  6177  
  6178  func (p *TtlArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  6179  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  6180  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  6181  	}
  6182  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  6183  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  6184  	}
  6185  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6186  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  6187  	}
  6188  	return err
  6189  }
  6190  
  6191  func (p *TtlArgs) String() string {
  6192  	if p == nil {
  6193  		return "<nil>"
  6194  	}
  6195  	return fmt.Sprintf("TtlArgs(%+v)", *p)
  6196  }
  6197  
  6198  // Attributes:
  6199  //  - Success
  6200  type TtlResult struct {
  6201  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  6202  }
  6203  
  6204  func NewTTLResult() *TtlResult {
  6205  	return &TtlResult{}
  6206  }
  6207  
  6208  var TTLResult_Success_DEFAULT *IntResponse
  6209  
  6210  func (p *TtlResult) GetSuccess() *IntResponse {
  6211  	if !p.IsSetSuccess() {
  6212  		return TTLResult_Success_DEFAULT
  6213  	}
  6214  	return p.Success
  6215  }
  6216  
  6217  func (p *TtlResult) IsSetSuccess() bool {
  6218  	return p.Success != nil
  6219  }
  6220  
  6221  func (p *TtlResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  6222  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6223  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6224  	}
  6225  
  6226  	for {
  6227  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6228  		if err != nil {
  6229  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6230  		}
  6231  		if fieldTypeId == thrift.STOP {
  6232  			break
  6233  		}
  6234  		switch fieldId {
  6235  		case 0:
  6236  			if fieldTypeId == thrift.STRUCT {
  6237  				if err := p.ReadField0(ctx, tp); err != nil {
  6238  					return err
  6239  				}
  6240  			} else {
  6241  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6242  					return err
  6243  				}
  6244  			}
  6245  		default:
  6246  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6247  				return err
  6248  			}
  6249  		}
  6250  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6251  			return err
  6252  		}
  6253  	}
  6254  	if err := tp.ReadStructEnd(ctx); err != nil {
  6255  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6256  	}
  6257  	return nil
  6258  }
  6259  
  6260  func (p *TtlResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  6261  	p.Success = &IntResponse{}
  6262  	if err := p.Success.Read(ctx, tp); err != nil {
  6263  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  6264  	}
  6265  	return nil
  6266  }
  6267  
  6268  func (p *TtlResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  6269  	if err := tp.WriteStructBegin(ctx, "TTL_result"); err != nil {
  6270  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6271  	}
  6272  	if p != nil {
  6273  		if err := p.writeField0(ctx, tp); err != nil {
  6274  			return err
  6275  		}
  6276  	}
  6277  	if err := tp.WriteFieldStop(ctx); err != nil {
  6278  		return thrift.PrependError("write field stop error: ", err)
  6279  	}
  6280  	if err := tp.WriteStructEnd(ctx); err != nil {
  6281  		return thrift.PrependError("write struct stop error: ", err)
  6282  	}
  6283  	return nil
  6284  }
  6285  
  6286  func (p *TtlResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  6287  	if p.IsSetSuccess() {
  6288  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  6289  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  6290  		}
  6291  		if err := p.Success.Write(ctx, tp); err != nil {
  6292  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  6293  		}
  6294  		if err := tp.WriteFieldEnd(ctx); err != nil {
  6295  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  6296  		}
  6297  	}
  6298  	return err
  6299  }
  6300  
  6301  func (p *TtlResult) String() string {
  6302  	if p == nil {
  6303  		return "<nil>"
  6304  	}
  6305  	return fmt.Sprintf("TtlResult(%+v)", *p)
  6306  }
  6307  
  6308  // Attributes:
  6309  //  - Appid
  6310  //  - Key
  6311  type ExistsArgs struct {
  6312  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  6313  	Key   string `thrift:"key,2" db:"key" json:"key"`
  6314  }
  6315  
  6316  func NewExistsArgs() *ExistsArgs {
  6317  	return &ExistsArgs{}
  6318  }
  6319  
  6320  func (p *ExistsArgs) GetAppid() string {
  6321  	return p.Appid
  6322  }
  6323  
  6324  func (p *ExistsArgs) GetKey() string {
  6325  	return p.Key
  6326  }
  6327  func (p *ExistsArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  6328  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6329  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6330  	}
  6331  
  6332  	for {
  6333  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6334  		if err != nil {
  6335  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6336  		}
  6337  		if fieldTypeId == thrift.STOP {
  6338  			break
  6339  		}
  6340  		switch fieldId {
  6341  		case 1:
  6342  			if fieldTypeId == thrift.STRING {
  6343  				if err := p.ReadField1(ctx, tp); err != nil {
  6344  					return err
  6345  				}
  6346  			} else {
  6347  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6348  					return err
  6349  				}
  6350  			}
  6351  		case 2:
  6352  			if fieldTypeId == thrift.STRING {
  6353  				if err := p.ReadField2(ctx, tp); err != nil {
  6354  					return err
  6355  				}
  6356  			} else {
  6357  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6358  					return err
  6359  				}
  6360  			}
  6361  		default:
  6362  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6363  				return err
  6364  			}
  6365  		}
  6366  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6367  			return err
  6368  		}
  6369  	}
  6370  	if err := tp.ReadStructEnd(ctx); err != nil {
  6371  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6372  	}
  6373  	return nil
  6374  }
  6375  
  6376  func (p *ExistsArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  6377  	if v, err := tp.ReadString(ctx); err != nil {
  6378  		return thrift.PrependError("error reading field 1: ", err)
  6379  	} else {
  6380  		p.Appid = v
  6381  	}
  6382  	return nil
  6383  }
  6384  
  6385  func (p *ExistsArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  6386  	if v, err := tp.ReadString(ctx); err != nil {
  6387  		return thrift.PrependError("error reading field 2: ", err)
  6388  	} else {
  6389  		p.Key = v
  6390  	}
  6391  	return nil
  6392  }
  6393  
  6394  func (p *ExistsArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  6395  	if err := tp.WriteStructBegin(ctx, "Exists_args"); err != nil {
  6396  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6397  	}
  6398  	if p != nil {
  6399  		if err := p.writeField1(ctx, tp); err != nil {
  6400  			return err
  6401  		}
  6402  		if err := p.writeField2(ctx, tp); err != nil {
  6403  			return err
  6404  		}
  6405  	}
  6406  	if err := tp.WriteFieldStop(ctx); err != nil {
  6407  		return thrift.PrependError("write field stop error: ", err)
  6408  	}
  6409  	if err := tp.WriteStructEnd(ctx); err != nil {
  6410  		return thrift.PrependError("write struct stop error: ", err)
  6411  	}
  6412  	return nil
  6413  }
  6414  
  6415  func (p *ExistsArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  6416  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  6417  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  6418  	}
  6419  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  6420  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  6421  	}
  6422  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6423  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  6424  	}
  6425  	return err
  6426  }
  6427  
  6428  func (p *ExistsArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  6429  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  6430  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  6431  	}
  6432  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  6433  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  6434  	}
  6435  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6436  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  6437  	}
  6438  	return err
  6439  }
  6440  
  6441  func (p *ExistsArgs) String() string {
  6442  	if p == nil {
  6443  		return "<nil>"
  6444  	}
  6445  	return fmt.Sprintf("ExistsArgs(%+v)", *p)
  6446  }
  6447  
  6448  // Attributes:
  6449  //  - Success
  6450  type ExistsResult struct {
  6451  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  6452  }
  6453  
  6454  func NewExistsResult() *ExistsResult {
  6455  	return &ExistsResult{}
  6456  }
  6457  
  6458  var ExistsResult_Success_DEFAULT *Response
  6459  
  6460  func (p *ExistsResult) GetSuccess() *Response {
  6461  	if !p.IsSetSuccess() {
  6462  		return ExistsResult_Success_DEFAULT
  6463  	}
  6464  	return p.Success
  6465  }
  6466  
  6467  func (p *ExistsResult) IsSetSuccess() bool {
  6468  	return p.Success != nil
  6469  }
  6470  
  6471  func (p *ExistsResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  6472  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6473  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6474  	}
  6475  
  6476  	for {
  6477  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6478  		if err != nil {
  6479  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6480  		}
  6481  		if fieldTypeId == thrift.STOP {
  6482  			break
  6483  		}
  6484  		switch fieldId {
  6485  		case 0:
  6486  			if fieldTypeId == thrift.STRUCT {
  6487  				if err := p.ReadField0(ctx, tp); err != nil {
  6488  					return err
  6489  				}
  6490  			} else {
  6491  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6492  					return err
  6493  				}
  6494  			}
  6495  		default:
  6496  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6497  				return err
  6498  			}
  6499  		}
  6500  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6501  			return err
  6502  		}
  6503  	}
  6504  	if err := tp.ReadStructEnd(ctx); err != nil {
  6505  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6506  	}
  6507  	return nil
  6508  }
  6509  
  6510  func (p *ExistsResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  6511  	p.Success = &Response{}
  6512  	if err := p.Success.Read(ctx, tp); err != nil {
  6513  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  6514  	}
  6515  	return nil
  6516  }
  6517  
  6518  func (p *ExistsResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  6519  	if err := tp.WriteStructBegin(ctx, "Exists_result"); err != nil {
  6520  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6521  	}
  6522  	if p != nil {
  6523  		if err := p.writeField0(ctx, tp); err != nil {
  6524  			return err
  6525  		}
  6526  	}
  6527  	if err := tp.WriteFieldStop(ctx); err != nil {
  6528  		return thrift.PrependError("write field stop error: ", err)
  6529  	}
  6530  	if err := tp.WriteStructEnd(ctx); err != nil {
  6531  		return thrift.PrependError("write struct stop error: ", err)
  6532  	}
  6533  	return nil
  6534  }
  6535  
  6536  func (p *ExistsResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  6537  	if p.IsSetSuccess() {
  6538  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  6539  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  6540  		}
  6541  		if err := p.Success.Write(ctx, tp); err != nil {
  6542  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  6543  		}
  6544  		if err := tp.WriteFieldEnd(ctx); err != nil {
  6545  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  6546  		}
  6547  	}
  6548  	return err
  6549  }
  6550  
  6551  func (p *ExistsResult) String() string {
  6552  	if p == nil {
  6553  		return "<nil>"
  6554  	}
  6555  	return fmt.Sprintf("ExistsResult(%+v)", *p)
  6556  }
  6557  
  6558  // Attributes:
  6559  //  - Appid
  6560  //  - Key
  6561  //  - Field
  6562  //  - Value
  6563  type HSetArgs struct {
  6564  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  6565  	Key   string `thrift:"key,2" db:"key" json:"key"`
  6566  	Field string `thrift:"field,3" db:"field" json:"field"`
  6567  	Value string `thrift:"value,4" db:"value" json:"value"`
  6568  }
  6569  
  6570  func NewHSetArgs() *HSetArgs {
  6571  	return &HSetArgs{}
  6572  }
  6573  
  6574  func (p *HSetArgs) GetAppid() string {
  6575  	return p.Appid
  6576  }
  6577  
  6578  func (p *HSetArgs) GetKey() string {
  6579  	return p.Key
  6580  }
  6581  
  6582  func (p *HSetArgs) GetField() string {
  6583  	return p.Field
  6584  }
  6585  
  6586  func (p *HSetArgs) GetValue() string {
  6587  	return p.Value
  6588  }
  6589  
  6590  func (p *HSetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  6591  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6592  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6593  	}
  6594  
  6595  	for {
  6596  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6597  		if err != nil {
  6598  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6599  		}
  6600  		if fieldTypeId == thrift.STOP {
  6601  			break
  6602  		}
  6603  		switch fieldId {
  6604  		case 1:
  6605  			if fieldTypeId == thrift.STRING {
  6606  				if err := p.ReadField1(ctx, tp); err != nil {
  6607  					return err
  6608  				}
  6609  			} else {
  6610  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6611  					return err
  6612  				}
  6613  			}
  6614  		case 2:
  6615  			if fieldTypeId == thrift.STRING {
  6616  				if err := p.ReadField2(ctx, tp); err != nil {
  6617  					return err
  6618  				}
  6619  			} else {
  6620  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6621  					return err
  6622  				}
  6623  			}
  6624  		case 3:
  6625  			if fieldTypeId == thrift.STRING {
  6626  				if err := p.ReadField3(ctx, tp); err != nil {
  6627  					return err
  6628  				}
  6629  			} else {
  6630  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6631  					return err
  6632  				}
  6633  			}
  6634  		case 4:
  6635  			if fieldTypeId == thrift.STRING {
  6636  				if err := p.ReadField4(ctx, tp); err != nil {
  6637  					return err
  6638  				}
  6639  			} else {
  6640  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6641  					return err
  6642  				}
  6643  			}
  6644  		default:
  6645  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6646  				return err
  6647  			}
  6648  		}
  6649  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6650  			return err
  6651  		}
  6652  	}
  6653  	if err := tp.ReadStructEnd(ctx); err != nil {
  6654  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6655  	}
  6656  	return nil
  6657  }
  6658  
  6659  func (p *HSetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  6660  	if v, err := tp.ReadString(ctx); err != nil {
  6661  		return thrift.PrependError("error reading field 1: ", err)
  6662  	} else {
  6663  		p.Appid = v
  6664  	}
  6665  	return nil
  6666  }
  6667  
  6668  func (p *HSetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  6669  	if v, err := tp.ReadString(ctx); err != nil {
  6670  		return thrift.PrependError("error reading field 2: ", err)
  6671  	} else {
  6672  		p.Key = v
  6673  	}
  6674  	return nil
  6675  }
  6676  
  6677  func (p *HSetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  6678  	if v, err := tp.ReadString(ctx); err != nil {
  6679  		return thrift.PrependError("error reading field 3: ", err)
  6680  	} else {
  6681  		p.Field = v
  6682  	}
  6683  	return nil
  6684  }
  6685  
  6686  func (p *HSetArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  6687  	if v, err := tp.ReadString(ctx); err != nil {
  6688  		return thrift.PrependError("error reading field 4: ", err)
  6689  	} else {
  6690  		p.Value = v
  6691  	}
  6692  	return nil
  6693  }
  6694  
  6695  func (p *HSetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  6696  	if err := tp.WriteStructBegin(ctx, "HSet_args"); err != nil {
  6697  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6698  	}
  6699  	if p != nil {
  6700  		if err := p.writeField1(ctx, tp); err != nil {
  6701  			return err
  6702  		}
  6703  		if err := p.writeField2(ctx, tp); err != nil {
  6704  			return err
  6705  		}
  6706  		if err := p.writeField3(ctx, tp); err != nil {
  6707  			return err
  6708  		}
  6709  		if err := p.writeField4(ctx, tp); err != nil {
  6710  			return err
  6711  		}
  6712  	}
  6713  	if err := tp.WriteFieldStop(ctx); err != nil {
  6714  		return thrift.PrependError("write field stop error: ", err)
  6715  	}
  6716  	if err := tp.WriteStructEnd(ctx); err != nil {
  6717  		return thrift.PrependError("write struct stop error: ", err)
  6718  	}
  6719  	return nil
  6720  }
  6721  
  6722  func (p *HSetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  6723  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  6724  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  6725  	}
  6726  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  6727  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  6728  	}
  6729  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6730  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  6731  	}
  6732  	return err
  6733  }
  6734  
  6735  func (p *HSetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  6736  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  6737  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  6738  	}
  6739  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  6740  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  6741  	}
  6742  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6743  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  6744  	}
  6745  	return err
  6746  }
  6747  
  6748  func (p *HSetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  6749  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  6750  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  6751  	}
  6752  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  6753  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  6754  	}
  6755  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6756  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  6757  	}
  6758  	return err
  6759  }
  6760  
  6761  func (p *HSetArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  6762  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
  6763  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
  6764  	}
  6765  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  6766  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
  6767  	}
  6768  	if err := tp.WriteFieldEnd(ctx); err != nil {
  6769  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
  6770  	}
  6771  	return err
  6772  }
  6773  
  6774  func (p *HSetArgs) String() string {
  6775  	if p == nil {
  6776  		return "<nil>"
  6777  	}
  6778  	return fmt.Sprintf("HSetArgs(%+v)", *p)
  6779  }
  6780  
  6781  // Attributes:
  6782  //  - Success
  6783  type HSetResult struct {
  6784  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  6785  }
  6786  
  6787  func NewHSetResult() *HSetResult {
  6788  	return &HSetResult{}
  6789  }
  6790  
  6791  var HSetResult_Success_DEFAULT *Response
  6792  
  6793  func (p *HSetResult) GetSuccess() *Response {
  6794  	if !p.IsSetSuccess() {
  6795  		return HSetResult_Success_DEFAULT
  6796  	}
  6797  	return p.Success
  6798  }
  6799  func (p *HSetResult) IsSetSuccess() bool {
  6800  	return p.Success != nil
  6801  }
  6802  
  6803  func (p *HSetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  6804  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6805  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6806  	}
  6807  
  6808  	for {
  6809  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6810  		if err != nil {
  6811  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6812  		}
  6813  		if fieldTypeId == thrift.STOP {
  6814  			break
  6815  		}
  6816  		switch fieldId {
  6817  		case 0:
  6818  			if fieldTypeId == thrift.STRUCT {
  6819  				if err := p.ReadField0(ctx, tp); err != nil {
  6820  					return err
  6821  				}
  6822  			} else {
  6823  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6824  					return err
  6825  				}
  6826  			}
  6827  		default:
  6828  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6829  				return err
  6830  			}
  6831  		}
  6832  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6833  			return err
  6834  		}
  6835  	}
  6836  	if err := tp.ReadStructEnd(ctx); err != nil {
  6837  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6838  	}
  6839  	return nil
  6840  }
  6841  
  6842  func (p *HSetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  6843  	p.Success = &Response{}
  6844  	if err := p.Success.Read(ctx, tp); err != nil {
  6845  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  6846  	}
  6847  	return nil
  6848  }
  6849  
  6850  func (p *HSetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  6851  	if err := tp.WriteStructBegin(ctx, "HSet_result"); err != nil {
  6852  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  6853  	}
  6854  	if p != nil {
  6855  		if err := p.writeField0(ctx, tp); err != nil {
  6856  			return err
  6857  		}
  6858  	}
  6859  	if err := tp.WriteFieldStop(ctx); err != nil {
  6860  		return thrift.PrependError("write field stop error: ", err)
  6861  	}
  6862  	if err := tp.WriteStructEnd(ctx); err != nil {
  6863  		return thrift.PrependError("write struct stop error: ", err)
  6864  	}
  6865  	return nil
  6866  }
  6867  
  6868  func (p *HSetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  6869  	if p.IsSetSuccess() {
  6870  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  6871  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  6872  		}
  6873  		if err := p.Success.Write(ctx, tp); err != nil {
  6874  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  6875  		}
  6876  		if err := tp.WriteFieldEnd(ctx); err != nil {
  6877  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  6878  		}
  6879  	}
  6880  	return err
  6881  }
  6882  
  6883  func (p *HSetResult) String() string {
  6884  	if p == nil {
  6885  		return "<nil>"
  6886  	}
  6887  	return fmt.Sprintf("HSetResult(%+v)", *p)
  6888  }
  6889  
  6890  // Attributes:
  6891  //  - Appid
  6892  //  - Key
  6893  //  - Field
  6894  //  - Value
  6895  type HSetBytesArgs struct {
  6896  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  6897  	Key   string `thrift:"key,2" db:"key" json:"key"`
  6898  	Field string `thrift:"field,3" db:"field" json:"field"`
  6899  	Value []byte `thrift:"value,4" db:"value" json:"value"`
  6900  }
  6901  
  6902  func NewHSetBytesArgs() *HSetBytesArgs {
  6903  	return &HSetBytesArgs{}
  6904  }
  6905  
  6906  func (p *HSetBytesArgs) GetAppid() string {
  6907  	return p.Appid
  6908  }
  6909  
  6910  func (p *HSetBytesArgs) GetKey() string {
  6911  	return p.Key
  6912  }
  6913  
  6914  func (p *HSetBytesArgs) GetField() string {
  6915  	return p.Field
  6916  }
  6917  
  6918  func (p *HSetBytesArgs) GetValue() []byte {
  6919  	return p.Value
  6920  }
  6921  func (p *HSetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  6922  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  6923  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  6924  	}
  6925  
  6926  	for {
  6927  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  6928  		if err != nil {
  6929  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  6930  		}
  6931  		if fieldTypeId == thrift.STOP {
  6932  			break
  6933  		}
  6934  		switch fieldId {
  6935  		case 1:
  6936  			if fieldTypeId == thrift.STRING {
  6937  				if err := p.ReadField1(ctx, tp); err != nil {
  6938  					return err
  6939  				}
  6940  			} else {
  6941  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6942  					return err
  6943  				}
  6944  			}
  6945  		case 2:
  6946  			if fieldTypeId == thrift.STRING {
  6947  				if err := p.ReadField2(ctx, tp); err != nil {
  6948  					return err
  6949  				}
  6950  			} else {
  6951  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6952  					return err
  6953  				}
  6954  			}
  6955  		case 3:
  6956  			if fieldTypeId == thrift.STRING {
  6957  				if err := p.ReadField3(ctx, tp); err != nil {
  6958  					return err
  6959  				}
  6960  			} else {
  6961  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6962  					return err
  6963  				}
  6964  			}
  6965  		case 4:
  6966  			if fieldTypeId == thrift.STRING {
  6967  				if err := p.ReadField4(ctx, tp); err != nil {
  6968  					return err
  6969  				}
  6970  			} else {
  6971  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6972  					return err
  6973  				}
  6974  			}
  6975  		default:
  6976  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  6977  				return err
  6978  			}
  6979  		}
  6980  		if err := tp.ReadFieldEnd(ctx); err != nil {
  6981  			return err
  6982  		}
  6983  	}
  6984  	if err := tp.ReadStructEnd(ctx); err != nil {
  6985  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  6986  	}
  6987  	return nil
  6988  }
  6989  
  6990  func (p *HSetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  6991  	if v, err := tp.ReadString(ctx); err != nil {
  6992  		return thrift.PrependError("error reading field 1: ", err)
  6993  	} else {
  6994  		p.Appid = v
  6995  	}
  6996  	return nil
  6997  }
  6998  
  6999  func (p *HSetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  7000  	if v, err := tp.ReadString(ctx); err != nil {
  7001  		return thrift.PrependError("error reading field 2: ", err)
  7002  	} else {
  7003  		p.Key = v
  7004  	}
  7005  	return nil
  7006  }
  7007  
  7008  func (p *HSetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  7009  	if v, err := tp.ReadString(ctx); err != nil {
  7010  		return thrift.PrependError("error reading field 3: ", err)
  7011  	} else {
  7012  		p.Field = v
  7013  	}
  7014  	return nil
  7015  }
  7016  
  7017  func (p *HSetBytesArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  7018  	if v, err := tp.ReadBinary(ctx); err != nil {
  7019  		return thrift.PrependError("error reading field 4: ", err)
  7020  	} else {
  7021  		p.Value = v
  7022  	}
  7023  	return nil
  7024  }
  7025  
  7026  func (p *HSetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  7027  	if err := tp.WriteStructBegin(ctx, "HSetBytes_args"); err != nil {
  7028  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7029  	}
  7030  	if p != nil {
  7031  		if err := p.writeField1(ctx, tp); err != nil {
  7032  			return err
  7033  		}
  7034  		if err := p.writeField2(ctx, tp); err != nil {
  7035  			return err
  7036  		}
  7037  		if err := p.writeField3(ctx, tp); err != nil {
  7038  			return err
  7039  		}
  7040  		if err := p.writeField4(ctx, tp); err != nil {
  7041  			return err
  7042  		}
  7043  	}
  7044  	if err := tp.WriteFieldStop(ctx); err != nil {
  7045  		return thrift.PrependError("write field stop error: ", err)
  7046  	}
  7047  	if err := tp.WriteStructEnd(ctx); err != nil {
  7048  		return thrift.PrependError("write struct stop error: ", err)
  7049  	}
  7050  	return nil
  7051  }
  7052  
  7053  func (p *HSetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  7054  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  7055  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  7056  	}
  7057  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  7058  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  7059  	}
  7060  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7061  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  7062  	}
  7063  	return err
  7064  }
  7065  
  7066  func (p *HSetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  7067  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  7068  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  7069  	}
  7070  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  7071  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  7072  	}
  7073  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7074  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  7075  	}
  7076  	return err
  7077  }
  7078  
  7079  func (p *HSetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  7080  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  7081  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  7082  	}
  7083  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  7084  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  7085  	}
  7086  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7087  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  7088  	}
  7089  	return err
  7090  }
  7091  
  7092  func (p *HSetBytesArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  7093  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
  7094  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
  7095  	}
  7096  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
  7097  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
  7098  	}
  7099  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7100  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
  7101  	}
  7102  	return err
  7103  }
  7104  
  7105  func (p *HSetBytesArgs) String() string {
  7106  	if p == nil {
  7107  		return "<nil>"
  7108  	}
  7109  	return fmt.Sprintf("HSetBytesArgs(%+v)", *p)
  7110  }
  7111  
  7112  // Attributes:
  7113  //  - Success
  7114  type HSetBytesResult struct {
  7115  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  7116  }
  7117  
  7118  func NewHSetBytesResult() *HSetBytesResult {
  7119  	return &HSetBytesResult{}
  7120  }
  7121  
  7122  var HSetBytesResult_Success_DEFAULT *Response
  7123  
  7124  func (p *HSetBytesResult) GetSuccess() *Response {
  7125  	if !p.IsSetSuccess() {
  7126  		return HSetBytesResult_Success_DEFAULT
  7127  	}
  7128  	return p.Success
  7129  }
  7130  func (p *HSetBytesResult) IsSetSuccess() bool {
  7131  	return p.Success != nil
  7132  }
  7133  
  7134  func (p *HSetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  7135  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7136  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7137  	}
  7138  
  7139  	for {
  7140  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7141  		if err != nil {
  7142  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7143  		}
  7144  		if fieldTypeId == thrift.STOP {
  7145  			break
  7146  		}
  7147  		switch fieldId {
  7148  		case 0:
  7149  			if fieldTypeId == thrift.STRUCT {
  7150  				if err := p.ReadField0(ctx, tp); err != nil {
  7151  					return err
  7152  				}
  7153  			} else {
  7154  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7155  					return err
  7156  				}
  7157  			}
  7158  		default:
  7159  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7160  				return err
  7161  			}
  7162  		}
  7163  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7164  			return err
  7165  		}
  7166  	}
  7167  	if err := tp.ReadStructEnd(ctx); err != nil {
  7168  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7169  	}
  7170  	return nil
  7171  }
  7172  
  7173  func (p *HSetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  7174  	p.Success = &Response{}
  7175  	if err := p.Success.Read(ctx, tp); err != nil {
  7176  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  7177  	}
  7178  	return nil
  7179  }
  7180  
  7181  func (p *HSetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  7182  	if err := tp.WriteStructBegin(ctx, "HSetBytes_result"); err != nil {
  7183  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7184  	}
  7185  	if p != nil {
  7186  		if err := p.writeField0(ctx, tp); err != nil {
  7187  			return err
  7188  		}
  7189  	}
  7190  	if err := tp.WriteFieldStop(ctx); err != nil {
  7191  		return thrift.PrependError("write field stop error: ", err)
  7192  	}
  7193  	if err := tp.WriteStructEnd(ctx); err != nil {
  7194  		return thrift.PrependError("write struct stop error: ", err)
  7195  	}
  7196  	return nil
  7197  }
  7198  
  7199  func (p *HSetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  7200  	if p.IsSetSuccess() {
  7201  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  7202  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  7203  		}
  7204  		if err := p.Success.Write(ctx, tp); err != nil {
  7205  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  7206  		}
  7207  		if err := tp.WriteFieldEnd(ctx); err != nil {
  7208  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  7209  		}
  7210  	}
  7211  	return err
  7212  }
  7213  
  7214  func (p *HSetBytesResult) String() string {
  7215  	if p == nil {
  7216  		return "<nil>"
  7217  	}
  7218  	return fmt.Sprintf("HSetBytesResult(%+v)", *p)
  7219  }
  7220  
  7221  // Attributes:
  7222  //  - Appid
  7223  //  - Key
  7224  //  - Field
  7225  //  - Value
  7226  type HSetNXArgs struct {
  7227  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  7228  	Key   string `thrift:"key,2" db:"key" json:"key"`
  7229  	Field string `thrift:"field,3" db:"field" json:"field"`
  7230  	Value string `thrift:"value,4" db:"value" json:"value"`
  7231  }
  7232  
  7233  func NewHSetNXArgs() *HSetNXArgs {
  7234  	return &HSetNXArgs{}
  7235  }
  7236  
  7237  func (p *HSetNXArgs) GetAppid() string {
  7238  	return p.Appid
  7239  }
  7240  
  7241  func (p *HSetNXArgs) GetKey() string {
  7242  	return p.Key
  7243  }
  7244  
  7245  func (p *HSetNXArgs) GetField() string {
  7246  	return p.Field
  7247  }
  7248  
  7249  func (p *HSetNXArgs) GetValue() string {
  7250  	return p.Value
  7251  }
  7252  func (p *HSetNXArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  7253  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7254  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7255  	}
  7256  
  7257  	for {
  7258  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7259  		if err != nil {
  7260  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7261  		}
  7262  		if fieldTypeId == thrift.STOP {
  7263  			break
  7264  		}
  7265  		switch fieldId {
  7266  		case 1:
  7267  			if fieldTypeId == thrift.STRING {
  7268  				if err := p.ReadField1(ctx, tp); err != nil {
  7269  					return err
  7270  				}
  7271  			} else {
  7272  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7273  					return err
  7274  				}
  7275  			}
  7276  		case 2:
  7277  			if fieldTypeId == thrift.STRING {
  7278  				if err := p.ReadField2(ctx, tp); err != nil {
  7279  					return err
  7280  				}
  7281  			} else {
  7282  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7283  					return err
  7284  				}
  7285  			}
  7286  		case 3:
  7287  			if fieldTypeId == thrift.STRING {
  7288  				if err := p.ReadField3(ctx, tp); err != nil {
  7289  					return err
  7290  				}
  7291  			} else {
  7292  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7293  					return err
  7294  				}
  7295  			}
  7296  		case 4:
  7297  			if fieldTypeId == thrift.STRING {
  7298  				if err := p.ReadField4(ctx, tp); err != nil {
  7299  					return err
  7300  				}
  7301  			} else {
  7302  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7303  					return err
  7304  				}
  7305  			}
  7306  		default:
  7307  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7308  				return err
  7309  			}
  7310  		}
  7311  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7312  			return err
  7313  		}
  7314  	}
  7315  	if err := tp.ReadStructEnd(ctx); err != nil {
  7316  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7317  	}
  7318  	return nil
  7319  }
  7320  
  7321  func (p *HSetNXArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  7322  	if v, err := tp.ReadString(ctx); err != nil {
  7323  		return thrift.PrependError("error reading field 1: ", err)
  7324  	} else {
  7325  		p.Appid = v
  7326  	}
  7327  	return nil
  7328  }
  7329  
  7330  func (p *HSetNXArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  7331  	if v, err := tp.ReadString(ctx); err != nil {
  7332  		return thrift.PrependError("error reading field 2: ", err)
  7333  	} else {
  7334  		p.Key = v
  7335  	}
  7336  	return nil
  7337  }
  7338  
  7339  func (p *HSetNXArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  7340  	if v, err := tp.ReadString(ctx); err != nil {
  7341  		return thrift.PrependError("error reading field 3: ", err)
  7342  	} else {
  7343  		p.Field = v
  7344  	}
  7345  	return nil
  7346  }
  7347  
  7348  func (p *HSetNXArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  7349  	if v, err := tp.ReadString(ctx); err != nil {
  7350  		return thrift.PrependError("error reading field 4: ", err)
  7351  	} else {
  7352  		p.Value = v
  7353  	}
  7354  	return nil
  7355  }
  7356  
  7357  func (p *HSetNXArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  7358  	if err := tp.WriteStructBegin(ctx, "HSetNX_args"); err != nil {
  7359  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7360  	}
  7361  	if p != nil {
  7362  		if err := p.writeField1(ctx, tp); err != nil {
  7363  			return err
  7364  		}
  7365  		if err := p.writeField2(ctx, tp); err != nil {
  7366  			return err
  7367  		}
  7368  		if err := p.writeField3(ctx, tp); err != nil {
  7369  			return err
  7370  		}
  7371  		if err := p.writeField4(ctx, tp); err != nil {
  7372  			return err
  7373  		}
  7374  	}
  7375  	if err := tp.WriteFieldStop(ctx); err != nil {
  7376  		return thrift.PrependError("write field stop error: ", err)
  7377  	}
  7378  	if err := tp.WriteStructEnd(ctx); err != nil {
  7379  		return thrift.PrependError("write struct stop error: ", err)
  7380  	}
  7381  	return nil
  7382  }
  7383  
  7384  func (p *HSetNXArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  7385  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  7386  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  7387  	}
  7388  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  7389  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  7390  	}
  7391  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7392  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  7393  	}
  7394  	return err
  7395  }
  7396  
  7397  func (p *HSetNXArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  7398  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  7399  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  7400  	}
  7401  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  7402  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  7403  	}
  7404  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7405  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  7406  	}
  7407  	return err
  7408  }
  7409  
  7410  func (p *HSetNXArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  7411  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  7412  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  7413  	}
  7414  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  7415  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  7416  	}
  7417  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7418  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  7419  	}
  7420  	return err
  7421  }
  7422  
  7423  func (p *HSetNXArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  7424  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
  7425  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
  7426  	}
  7427  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  7428  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
  7429  	}
  7430  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7431  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
  7432  	}
  7433  	return err
  7434  }
  7435  
  7436  func (p *HSetNXArgs) String() string {
  7437  	if p == nil {
  7438  		return "<nil>"
  7439  	}
  7440  	return fmt.Sprintf("HSetNXArgs(%+v)", *p)
  7441  }
  7442  
  7443  // Attributes:
  7444  //  - Success
  7445  type HSetNXResult struct {
  7446  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  7447  }
  7448  
  7449  func NewRedisProxyHSetNXResult() *HSetNXResult {
  7450  	return &HSetNXResult{}
  7451  }
  7452  
  7453  var RedisProxyHSetNXResult_Success_DEFAULT *Response
  7454  
  7455  func (p *HSetNXResult) GetSuccess() *Response {
  7456  	if !p.IsSetSuccess() {
  7457  		return RedisProxyHSetNXResult_Success_DEFAULT
  7458  	}
  7459  	return p.Success
  7460  }
  7461  func (p *HSetNXResult) IsSetSuccess() bool {
  7462  	return p.Success != nil
  7463  }
  7464  
  7465  func (p *HSetNXResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  7466  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7467  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7468  	}
  7469  
  7470  	for {
  7471  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7472  		if err != nil {
  7473  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7474  		}
  7475  		if fieldTypeId == thrift.STOP {
  7476  			break
  7477  		}
  7478  		switch fieldId {
  7479  		case 0:
  7480  			if fieldTypeId == thrift.STRUCT {
  7481  				if err := p.ReadField0(ctx, tp); err != nil {
  7482  					return err
  7483  				}
  7484  			} else {
  7485  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7486  					return err
  7487  				}
  7488  			}
  7489  		default:
  7490  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7491  				return err
  7492  			}
  7493  		}
  7494  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7495  			return err
  7496  		}
  7497  	}
  7498  	if err := tp.ReadStructEnd(ctx); err != nil {
  7499  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7500  	}
  7501  	return nil
  7502  }
  7503  
  7504  func (p *HSetNXResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  7505  	p.Success = &Response{}
  7506  	if err := p.Success.Read(ctx, tp); err != nil {
  7507  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  7508  	}
  7509  	return nil
  7510  }
  7511  
  7512  func (p *HSetNXResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  7513  	if err := tp.WriteStructBegin(ctx, "HSetNX_result"); err != nil {
  7514  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7515  	}
  7516  	if p != nil {
  7517  		if err := p.writeField0(ctx, tp); err != nil {
  7518  			return err
  7519  		}
  7520  	}
  7521  	if err := tp.WriteFieldStop(ctx); err != nil {
  7522  		return thrift.PrependError("write field stop error: ", err)
  7523  	}
  7524  	if err := tp.WriteStructEnd(ctx); err != nil {
  7525  		return thrift.PrependError("write struct stop error: ", err)
  7526  	}
  7527  	return nil
  7528  }
  7529  
  7530  func (p *HSetNXResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  7531  	if p.IsSetSuccess() {
  7532  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  7533  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  7534  		}
  7535  		if err := p.Success.Write(ctx, tp); err != nil {
  7536  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  7537  		}
  7538  		if err := tp.WriteFieldEnd(ctx); err != nil {
  7539  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  7540  		}
  7541  	}
  7542  	return err
  7543  }
  7544  
  7545  func (p *HSetNXResult) String() string {
  7546  	if p == nil {
  7547  		return "<nil>"
  7548  	}
  7549  	return fmt.Sprintf("HSetNXResult(%+v)", *p)
  7550  }
  7551  
  7552  // Attributes:
  7553  //  - Appid
  7554  //  - Key
  7555  //  - Field
  7556  //  - Value
  7557  type HSetNXBytesArgs struct {
  7558  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  7559  	Key   string `thrift:"key,2" db:"key" json:"key"`
  7560  	Field string `thrift:"field,3" db:"field" json:"field"`
  7561  	Value string `thrift:"value,4" db:"value" json:"value"`
  7562  }
  7563  
  7564  func NewRedisProxyHSetNXBytesArgs() *HSetNXBytesArgs {
  7565  	return &HSetNXBytesArgs{}
  7566  }
  7567  
  7568  func (p *HSetNXBytesArgs) GetAppid() string {
  7569  	return p.Appid
  7570  }
  7571  
  7572  func (p *HSetNXBytesArgs) GetKey() string {
  7573  	return p.Key
  7574  }
  7575  
  7576  func (p *HSetNXBytesArgs) GetField() string {
  7577  	return p.Field
  7578  }
  7579  
  7580  func (p *HSetNXBytesArgs) GetValue() string {
  7581  	return p.Value
  7582  }
  7583  func (p *HSetNXBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  7584  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7585  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7586  	}
  7587  
  7588  	for {
  7589  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7590  		if err != nil {
  7591  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7592  		}
  7593  		if fieldTypeId == thrift.STOP {
  7594  			break
  7595  		}
  7596  		switch fieldId {
  7597  		case 1:
  7598  			if fieldTypeId == thrift.STRING {
  7599  				if err := p.ReadField1(ctx, tp); err != nil {
  7600  					return err
  7601  				}
  7602  			} else {
  7603  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7604  					return err
  7605  				}
  7606  			}
  7607  		case 2:
  7608  			if fieldTypeId == thrift.STRING {
  7609  				if err := p.ReadField2(ctx, tp); err != nil {
  7610  					return err
  7611  				}
  7612  			} else {
  7613  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7614  					return err
  7615  				}
  7616  			}
  7617  		case 3:
  7618  			if fieldTypeId == thrift.STRING {
  7619  				if err := p.ReadField3(ctx, tp); err != nil {
  7620  					return err
  7621  				}
  7622  			} else {
  7623  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7624  					return err
  7625  				}
  7626  			}
  7627  		case 4:
  7628  			if fieldTypeId == thrift.STRING {
  7629  				if err := p.ReadField4(ctx, tp); err != nil {
  7630  					return err
  7631  				}
  7632  			} else {
  7633  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7634  					return err
  7635  				}
  7636  			}
  7637  		default:
  7638  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7639  				return err
  7640  			}
  7641  		}
  7642  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7643  			return err
  7644  		}
  7645  	}
  7646  	if err := tp.ReadStructEnd(ctx); err != nil {
  7647  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7648  	}
  7649  	return nil
  7650  }
  7651  
  7652  func (p *HSetNXBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  7653  	if v, err := tp.ReadString(ctx); err != nil {
  7654  		return thrift.PrependError("error reading field 1: ", err)
  7655  	} else {
  7656  		p.Appid = v
  7657  	}
  7658  	return nil
  7659  }
  7660  
  7661  func (p *HSetNXBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  7662  	if v, err := tp.ReadString(ctx); err != nil {
  7663  		return thrift.PrependError("error reading field 2: ", err)
  7664  	} else {
  7665  		p.Key = v
  7666  	}
  7667  	return nil
  7668  }
  7669  
  7670  func (p *HSetNXBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  7671  	if v, err := tp.ReadString(ctx); err != nil {
  7672  		return thrift.PrependError("error reading field 3: ", err)
  7673  	} else {
  7674  		p.Field = v
  7675  	}
  7676  	return nil
  7677  }
  7678  
  7679  func (p *HSetNXBytesArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
  7680  	if v, err := tp.ReadString(ctx); err != nil {
  7681  		return thrift.PrependError("error reading field 4: ", err)
  7682  	} else {
  7683  		p.Value = v
  7684  	}
  7685  	return nil
  7686  }
  7687  
  7688  func (p *HSetNXBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  7689  	if err := tp.WriteStructBegin(ctx, "HSetNXBytes_args"); err != nil {
  7690  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7691  	}
  7692  	if p != nil {
  7693  		if err := p.writeField1(ctx, tp); err != nil {
  7694  			return err
  7695  		}
  7696  		if err := p.writeField2(ctx, tp); err != nil {
  7697  			return err
  7698  		}
  7699  		if err := p.writeField3(ctx, tp); err != nil {
  7700  			return err
  7701  		}
  7702  		if err := p.writeField4(ctx, tp); err != nil {
  7703  			return err
  7704  		}
  7705  	}
  7706  	if err := tp.WriteFieldStop(ctx); err != nil {
  7707  		return thrift.PrependError("write field stop error: ", err)
  7708  	}
  7709  	if err := tp.WriteStructEnd(ctx); err != nil {
  7710  		return thrift.PrependError("write struct stop error: ", err)
  7711  	}
  7712  	return nil
  7713  }
  7714  
  7715  func (p *HSetNXBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  7716  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  7717  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  7718  	}
  7719  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  7720  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  7721  	}
  7722  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7723  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  7724  	}
  7725  	return err
  7726  }
  7727  
  7728  func (p *HSetNXBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  7729  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  7730  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  7731  	}
  7732  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  7733  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  7734  	}
  7735  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7736  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  7737  	}
  7738  	return err
  7739  }
  7740  
  7741  func (p *HSetNXBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  7742  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  7743  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  7744  	}
  7745  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  7746  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  7747  	}
  7748  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7749  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  7750  	}
  7751  	return err
  7752  }
  7753  
  7754  func (p *HSetNXBytesArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
  7755  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
  7756  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
  7757  	}
  7758  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
  7759  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
  7760  	}
  7761  	if err := tp.WriteFieldEnd(ctx); err != nil {
  7762  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
  7763  	}
  7764  	return err
  7765  }
  7766  
  7767  func (p *HSetNXBytesArgs) String() string {
  7768  	if p == nil {
  7769  		return "<nil>"
  7770  	}
  7771  	return fmt.Sprintf("HSetNXBytesArgs(%+v)", *p)
  7772  }
  7773  
  7774  // Attributes:
  7775  //  - Success
  7776  type HSetNXBytesResult struct {
  7777  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  7778  }
  7779  
  7780  func NewHSetNXBytesResult() *HSetNXBytesResult {
  7781  	return &HSetNXBytesResult{}
  7782  }
  7783  
  7784  var HSetNXBytesResult_Success_DEFAULT *Response
  7785  
  7786  func (p *HSetNXBytesResult) GetSuccess() *Response {
  7787  	if !p.IsSetSuccess() {
  7788  		return HSetNXBytesResult_Success_DEFAULT
  7789  	}
  7790  	return p.Success
  7791  }
  7792  func (p *HSetNXBytesResult) IsSetSuccess() bool {
  7793  	return p.Success != nil
  7794  }
  7795  
  7796  func (p *HSetNXBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  7797  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7798  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7799  	}
  7800  
  7801  	for {
  7802  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7803  		if err != nil {
  7804  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7805  		}
  7806  		if fieldTypeId == thrift.STOP {
  7807  			break
  7808  		}
  7809  		switch fieldId {
  7810  		case 0:
  7811  			if fieldTypeId == thrift.STRUCT {
  7812  				if err := p.ReadField0(ctx, tp); err != nil {
  7813  					return err
  7814  				}
  7815  			} else {
  7816  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7817  					return err
  7818  				}
  7819  			}
  7820  		default:
  7821  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7822  				return err
  7823  			}
  7824  		}
  7825  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7826  			return err
  7827  		}
  7828  	}
  7829  	if err := tp.ReadStructEnd(ctx); err != nil {
  7830  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7831  	}
  7832  	return nil
  7833  }
  7834  
  7835  func (p *HSetNXBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  7836  	p.Success = &Response{}
  7837  	if err := p.Success.Read(ctx, tp); err != nil {
  7838  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  7839  	}
  7840  	return nil
  7841  }
  7842  
  7843  func (p *HSetNXBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  7844  	if err := tp.WriteStructBegin(ctx, "HSetNXBytes_result"); err != nil {
  7845  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7846  	}
  7847  	if p != nil {
  7848  		if err := p.writeField0(ctx, tp); err != nil {
  7849  			return err
  7850  		}
  7851  	}
  7852  	if err := tp.WriteFieldStop(ctx); err != nil {
  7853  		return thrift.PrependError("write field stop error: ", err)
  7854  	}
  7855  	if err := tp.WriteStructEnd(ctx); err != nil {
  7856  		return thrift.PrependError("write struct stop error: ", err)
  7857  	}
  7858  	return nil
  7859  }
  7860  
  7861  func (p *HSetNXBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  7862  	if p.IsSetSuccess() {
  7863  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  7864  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  7865  		}
  7866  		if err := p.Success.Write(ctx, tp); err != nil {
  7867  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  7868  		}
  7869  		if err := tp.WriteFieldEnd(ctx); err != nil {
  7870  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  7871  		}
  7872  	}
  7873  	return err
  7874  }
  7875  
  7876  func (p *HSetNXBytesResult) String() string {
  7877  	if p == nil {
  7878  		return "<nil>"
  7879  	}
  7880  	return fmt.Sprintf("HSetNXBytesResult(%+v)", *p)
  7881  }
  7882  
  7883  // Attributes:
  7884  //  - Appid
  7885  //  - Key
  7886  //  - Field
  7887  type ProxyHGetArgs struct {
  7888  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  7889  	Key   string `thrift:"key,2" db:"key" json:"key"`
  7890  	Field string `thrift:"field,3" db:"field" json:"field"`
  7891  }
  7892  
  7893  func NewHGetArgs() *ProxyHGetArgs {
  7894  	return &ProxyHGetArgs{}
  7895  }
  7896  
  7897  func (p *ProxyHGetArgs) GetAppid() string {
  7898  	return p.Appid
  7899  }
  7900  
  7901  func (p *ProxyHGetArgs) GetKey() string {
  7902  	return p.Key
  7903  }
  7904  
  7905  func (p *ProxyHGetArgs) GetField() string {
  7906  	return p.Field
  7907  }
  7908  func (p *ProxyHGetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  7909  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  7910  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  7911  	}
  7912  
  7913  	for {
  7914  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  7915  		if err != nil {
  7916  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  7917  		}
  7918  		if fieldTypeId == thrift.STOP {
  7919  			break
  7920  		}
  7921  		switch fieldId {
  7922  		case 1:
  7923  			if fieldTypeId == thrift.STRING {
  7924  				if err := p.ReadField1(ctx, tp); err != nil {
  7925  					return err
  7926  				}
  7927  			} else {
  7928  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7929  					return err
  7930  				}
  7931  			}
  7932  		case 2:
  7933  			if fieldTypeId == thrift.STRING {
  7934  				if err := p.ReadField2(ctx, tp); err != nil {
  7935  					return err
  7936  				}
  7937  			} else {
  7938  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7939  					return err
  7940  				}
  7941  			}
  7942  		case 3:
  7943  			if fieldTypeId == thrift.STRING {
  7944  				if err := p.ReadField3(ctx, tp); err != nil {
  7945  					return err
  7946  				}
  7947  			} else {
  7948  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7949  					return err
  7950  				}
  7951  			}
  7952  		default:
  7953  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  7954  				return err
  7955  			}
  7956  		}
  7957  		if err := tp.ReadFieldEnd(ctx); err != nil {
  7958  			return err
  7959  		}
  7960  	}
  7961  	if err := tp.ReadStructEnd(ctx); err != nil {
  7962  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  7963  	}
  7964  	return nil
  7965  }
  7966  
  7967  func (p *ProxyHGetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  7968  	if v, err := tp.ReadString(ctx); err != nil {
  7969  		return thrift.PrependError("error reading field 1: ", err)
  7970  	} else {
  7971  		p.Appid = v
  7972  	}
  7973  	return nil
  7974  }
  7975  
  7976  func (p *ProxyHGetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  7977  	if v, err := tp.ReadString(ctx); err != nil {
  7978  		return thrift.PrependError("error reading field 2: ", err)
  7979  	} else {
  7980  		p.Key = v
  7981  	}
  7982  	return nil
  7983  }
  7984  
  7985  func (p *ProxyHGetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  7986  	if v, err := tp.ReadString(ctx); err != nil {
  7987  		return thrift.PrependError("error reading field 3: ", err)
  7988  	} else {
  7989  		p.Field = v
  7990  	}
  7991  	return nil
  7992  }
  7993  
  7994  func (p *ProxyHGetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  7995  	if err := tp.WriteStructBegin(ctx, "HGet_args"); err != nil {
  7996  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  7997  	}
  7998  	if p != nil {
  7999  		if err := p.writeField1(ctx, tp); err != nil {
  8000  			return err
  8001  		}
  8002  		if err := p.writeField2(ctx, tp); err != nil {
  8003  			return err
  8004  		}
  8005  		if err := p.writeField3(ctx, tp); err != nil {
  8006  			return err
  8007  		}
  8008  	}
  8009  	if err := tp.WriteFieldStop(ctx); err != nil {
  8010  		return thrift.PrependError("write field stop error: ", err)
  8011  	}
  8012  	if err := tp.WriteStructEnd(ctx); err != nil {
  8013  		return thrift.PrependError("write struct stop error: ", err)
  8014  	}
  8015  	return nil
  8016  }
  8017  
  8018  func (p *ProxyHGetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  8019  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  8020  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  8021  	}
  8022  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  8023  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  8024  	}
  8025  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8026  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  8027  	}
  8028  	return err
  8029  }
  8030  
  8031  func (p *ProxyHGetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  8032  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  8033  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  8034  	}
  8035  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  8036  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  8037  	}
  8038  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8039  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  8040  	}
  8041  	return err
  8042  }
  8043  
  8044  func (p *ProxyHGetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  8045  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  8046  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  8047  	}
  8048  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  8049  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  8050  	}
  8051  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8052  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  8053  	}
  8054  	return err
  8055  }
  8056  
  8057  func (p *ProxyHGetArgs) String() string {
  8058  	if p == nil {
  8059  		return "<nil>"
  8060  	}
  8061  	return fmt.Sprintf("ProxyHGetArgs(%+v)", *p)
  8062  }
  8063  
  8064  // Attributes:
  8065  //  - Success
  8066  type HGetResult struct {
  8067  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  8068  }
  8069  
  8070  func NewHGetResult() *HGetResult {
  8071  	return &HGetResult{}
  8072  }
  8073  
  8074  var HGetResult_Success_DEFAULT *Response
  8075  
  8076  func (p *HGetResult) GetSuccess() *Response {
  8077  	if !p.IsSetSuccess() {
  8078  		return HGetResult_Success_DEFAULT
  8079  	}
  8080  	return p.Success
  8081  }
  8082  
  8083  func (p *HGetResult) IsSetSuccess() bool {
  8084  	return p.Success != nil
  8085  }
  8086  
  8087  func (p *HGetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  8088  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8089  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8090  	}
  8091  
  8092  	for {
  8093  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8094  		if err != nil {
  8095  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8096  		}
  8097  		if fieldTypeId == thrift.STOP {
  8098  			break
  8099  		}
  8100  		switch fieldId {
  8101  		case 0:
  8102  			if fieldTypeId == thrift.STRUCT {
  8103  				if err := p.ReadField0(ctx, tp); err != nil {
  8104  					return err
  8105  				}
  8106  			} else {
  8107  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8108  					return err
  8109  				}
  8110  			}
  8111  		default:
  8112  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8113  				return err
  8114  			}
  8115  		}
  8116  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8117  			return err
  8118  		}
  8119  	}
  8120  	if err := tp.ReadStructEnd(ctx); err != nil {
  8121  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8122  	}
  8123  	return nil
  8124  }
  8125  
  8126  func (p *HGetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  8127  	p.Success = &Response{}
  8128  	if err := p.Success.Read(ctx, tp); err != nil {
  8129  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  8130  	}
  8131  	return nil
  8132  }
  8133  
  8134  func (p *HGetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  8135  	if err := tp.WriteStructBegin(ctx, "HGet_result"); err != nil {
  8136  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8137  	}
  8138  	if p != nil {
  8139  		if err := p.writeField0(ctx, tp); err != nil {
  8140  			return err
  8141  		}
  8142  	}
  8143  	if err := tp.WriteFieldStop(ctx); err != nil {
  8144  		return thrift.PrependError("write field stop error: ", err)
  8145  	}
  8146  	if err := tp.WriteStructEnd(ctx); err != nil {
  8147  		return thrift.PrependError("write struct stop error: ", err)
  8148  	}
  8149  	return nil
  8150  }
  8151  
  8152  func (p *HGetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  8153  	if p.IsSetSuccess() {
  8154  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  8155  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  8156  		}
  8157  		if err := p.Success.Write(ctx, tp); err != nil {
  8158  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  8159  		}
  8160  		if err := tp.WriteFieldEnd(ctx); err != nil {
  8161  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  8162  		}
  8163  	}
  8164  	return err
  8165  }
  8166  
  8167  func (p *HGetResult) String() string {
  8168  	if p == nil {
  8169  		return "<nil>"
  8170  	}
  8171  	return fmt.Sprintf("HGetResult(%+v)", *p)
  8172  }
  8173  
  8174  // Attributes:
  8175  //  - Appid
  8176  //  - Key
  8177  //  - Field
  8178  type RedisProxyHGetBytesArgs struct {
  8179  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  8180  	Key   string `thrift:"key,2" db:"key" json:"key"`
  8181  	Field string `thrift:"field,3" db:"field" json:"field"`
  8182  }
  8183  
  8184  func NewRedisProxyHGetBytesArgs() *RedisProxyHGetBytesArgs {
  8185  	return &RedisProxyHGetBytesArgs{}
  8186  }
  8187  
  8188  func (p *RedisProxyHGetBytesArgs) GetAppid() string {
  8189  	return p.Appid
  8190  }
  8191  
  8192  func (p *RedisProxyHGetBytesArgs) GetKey() string {
  8193  	return p.Key
  8194  }
  8195  
  8196  func (p *RedisProxyHGetBytesArgs) GetField() string {
  8197  	return p.Field
  8198  }
  8199  func (p *RedisProxyHGetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  8200  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8201  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8202  	}
  8203  
  8204  	for {
  8205  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8206  		if err != nil {
  8207  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8208  		}
  8209  		if fieldTypeId == thrift.STOP {
  8210  			break
  8211  		}
  8212  		switch fieldId {
  8213  		case 1:
  8214  			if fieldTypeId == thrift.STRING {
  8215  				if err := p.ReadField1(ctx, tp); err != nil {
  8216  					return err
  8217  				}
  8218  			} else {
  8219  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8220  					return err
  8221  				}
  8222  			}
  8223  		case 2:
  8224  			if fieldTypeId == thrift.STRING {
  8225  				if err := p.ReadField2(ctx, tp); err != nil {
  8226  					return err
  8227  				}
  8228  			} else {
  8229  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8230  					return err
  8231  				}
  8232  			}
  8233  		case 3:
  8234  			if fieldTypeId == thrift.STRING {
  8235  				if err := p.ReadField3(ctx, tp); err != nil {
  8236  					return err
  8237  				}
  8238  			} else {
  8239  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8240  					return err
  8241  				}
  8242  			}
  8243  		default:
  8244  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8245  				return err
  8246  			}
  8247  		}
  8248  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8249  			return err
  8250  		}
  8251  	}
  8252  	if err := tp.ReadStructEnd(ctx); err != nil {
  8253  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8254  	}
  8255  	return nil
  8256  }
  8257  
  8258  func (p *RedisProxyHGetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  8259  	if v, err := tp.ReadString(ctx); err != nil {
  8260  		return thrift.PrependError("error reading field 1: ", err)
  8261  	} else {
  8262  		p.Appid = v
  8263  	}
  8264  	return nil
  8265  }
  8266  
  8267  func (p *RedisProxyHGetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  8268  	if v, err := tp.ReadString(ctx); err != nil {
  8269  		return thrift.PrependError("error reading field 2: ", err)
  8270  	} else {
  8271  		p.Key = v
  8272  	}
  8273  	return nil
  8274  }
  8275  
  8276  func (p *RedisProxyHGetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  8277  	if v, err := tp.ReadString(ctx); err != nil {
  8278  		return thrift.PrependError("error reading field 3: ", err)
  8279  	} else {
  8280  		p.Field = v
  8281  	}
  8282  	return nil
  8283  }
  8284  
  8285  func (p *RedisProxyHGetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  8286  	if err := tp.WriteStructBegin(ctx, "HGetBytes_args"); err != nil {
  8287  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8288  	}
  8289  	if p != nil {
  8290  		if err := p.writeField1(ctx, tp); err != nil {
  8291  			return err
  8292  		}
  8293  		if err := p.writeField2(ctx, tp); err != nil {
  8294  			return err
  8295  		}
  8296  		if err := p.writeField3(ctx, tp); err != nil {
  8297  			return err
  8298  		}
  8299  	}
  8300  	if err := tp.WriteFieldStop(ctx); err != nil {
  8301  		return thrift.PrependError("write field stop error: ", err)
  8302  	}
  8303  	if err := tp.WriteStructEnd(ctx); err != nil {
  8304  		return thrift.PrependError("write struct stop error: ", err)
  8305  	}
  8306  	return nil
  8307  }
  8308  
  8309  func (p *RedisProxyHGetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  8310  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  8311  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  8312  	}
  8313  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  8314  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  8315  	}
  8316  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8317  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  8318  	}
  8319  	return err
  8320  }
  8321  
  8322  func (p *RedisProxyHGetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  8323  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  8324  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  8325  	}
  8326  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  8327  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  8328  	}
  8329  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8330  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  8331  	}
  8332  	return err
  8333  }
  8334  
  8335  func (p *RedisProxyHGetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  8336  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
  8337  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
  8338  	}
  8339  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
  8340  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
  8341  	}
  8342  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8343  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
  8344  	}
  8345  	return err
  8346  }
  8347  
  8348  func (p *RedisProxyHGetBytesArgs) String() string {
  8349  	if p == nil {
  8350  		return "<nil>"
  8351  	}
  8352  	return fmt.Sprintf("RedisProxyHGetBytesArgs(%+v)", *p)
  8353  }
  8354  
  8355  // Attributes:
  8356  //  - Success
  8357  type HGetBytesResult struct {
  8358  	Success *BytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  8359  }
  8360  
  8361  func NewHGetBytesResult() *HGetBytesResult {
  8362  	return &HGetBytesResult{}
  8363  }
  8364  
  8365  var HGetBytesResult_Success_DEFAULT *BytesResponse
  8366  
  8367  func (p *HGetBytesResult) GetSuccess() *BytesResponse {
  8368  	if !p.IsSetSuccess() {
  8369  		return HGetBytesResult_Success_DEFAULT
  8370  	}
  8371  	return p.Success
  8372  }
  8373  func (p *HGetBytesResult) IsSetSuccess() bool {
  8374  	return p.Success != nil
  8375  }
  8376  
  8377  func (p *HGetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  8378  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8379  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8380  	}
  8381  
  8382  	for {
  8383  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8384  		if err != nil {
  8385  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8386  		}
  8387  		if fieldTypeId == thrift.STOP {
  8388  			break
  8389  		}
  8390  		switch fieldId {
  8391  		case 0:
  8392  			if fieldTypeId == thrift.STRUCT {
  8393  				if err := p.ReadField0(ctx, tp); err != nil {
  8394  					return err
  8395  				}
  8396  			} else {
  8397  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8398  					return err
  8399  				}
  8400  			}
  8401  		default:
  8402  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8403  				return err
  8404  			}
  8405  		}
  8406  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8407  			return err
  8408  		}
  8409  	}
  8410  	if err := tp.ReadStructEnd(ctx); err != nil {
  8411  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8412  	}
  8413  	return nil
  8414  }
  8415  
  8416  func (p *HGetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  8417  	p.Success = &BytesResponse{}
  8418  	if err := p.Success.Read(ctx, tp); err != nil {
  8419  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  8420  	}
  8421  	return nil
  8422  }
  8423  
  8424  func (p *HGetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  8425  	if err := tp.WriteStructBegin(ctx, "HGetBytes_result"); err != nil {
  8426  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8427  	}
  8428  	if p != nil {
  8429  		if err := p.writeField0(ctx, tp); err != nil {
  8430  			return err
  8431  		}
  8432  	}
  8433  	if err := tp.WriteFieldStop(ctx); err != nil {
  8434  		return thrift.PrependError("write field stop error: ", err)
  8435  	}
  8436  	if err := tp.WriteStructEnd(ctx); err != nil {
  8437  		return thrift.PrependError("write struct stop error: ", err)
  8438  	}
  8439  	return nil
  8440  }
  8441  
  8442  func (p *HGetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  8443  	if p.IsSetSuccess() {
  8444  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  8445  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  8446  		}
  8447  		if err := p.Success.Write(ctx, tp); err != nil {
  8448  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  8449  		}
  8450  		if err := tp.WriteFieldEnd(ctx); err != nil {
  8451  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  8452  		}
  8453  	}
  8454  	return err
  8455  }
  8456  
  8457  func (p *HGetBytesResult) String() string {
  8458  	if p == nil {
  8459  		return "<nil>"
  8460  	}
  8461  	return fmt.Sprintf("HGetBytesResult(%+v)", *p)
  8462  }
  8463  
  8464  // Attributes:
  8465  //  - Appid
  8466  //  - Key
  8467  //  - Fields
  8468  type HmSetArgs struct {
  8469  	Appid  string            `thrift:"appid,1" db:"appid" json:"appid"`
  8470  	Key    string            `thrift:"key,2" db:"key" json:"key"`
  8471  	Fields map[string]string `thrift:"fields,3" db:"fields" json:"fields"`
  8472  }
  8473  
  8474  func NewRedisProxyHMSetArgs() *HmSetArgs {
  8475  	return &HmSetArgs{}
  8476  }
  8477  
  8478  func (p *HmSetArgs) GetAppid() string {
  8479  	return p.Appid
  8480  }
  8481  
  8482  func (p *HmSetArgs) GetKey() string {
  8483  	return p.Key
  8484  }
  8485  
  8486  func (p *HmSetArgs) GetFields() map[string]string {
  8487  	return p.Fields
  8488  }
  8489  func (p *HmSetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  8490  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8491  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8492  	}
  8493  
  8494  	for {
  8495  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8496  		if err != nil {
  8497  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8498  		}
  8499  		if fieldTypeId == thrift.STOP {
  8500  			break
  8501  		}
  8502  		switch fieldId {
  8503  		case 1:
  8504  			if fieldTypeId == thrift.STRING {
  8505  				if err := p.ReadField1(ctx, tp); err != nil {
  8506  					return err
  8507  				}
  8508  			} else {
  8509  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8510  					return err
  8511  				}
  8512  			}
  8513  		case 2:
  8514  			if fieldTypeId == thrift.STRING {
  8515  				if err := p.ReadField2(ctx, tp); err != nil {
  8516  					return err
  8517  				}
  8518  			} else {
  8519  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8520  					return err
  8521  				}
  8522  			}
  8523  		case 3:
  8524  			if fieldTypeId == thrift.MAP {
  8525  				if err := p.ReadField3(ctx, tp); err != nil {
  8526  					return err
  8527  				}
  8528  			} else {
  8529  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8530  					return err
  8531  				}
  8532  			}
  8533  		default:
  8534  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8535  				return err
  8536  			}
  8537  		}
  8538  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8539  			return err
  8540  		}
  8541  	}
  8542  	if err := tp.ReadStructEnd(ctx); err != nil {
  8543  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8544  	}
  8545  	return nil
  8546  }
  8547  
  8548  func (p *HmSetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  8549  	if v, err := tp.ReadString(ctx); err != nil {
  8550  		return thrift.PrependError("error reading field 1: ", err)
  8551  	} else {
  8552  		p.Appid = v
  8553  	}
  8554  	return nil
  8555  }
  8556  
  8557  func (p *HmSetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  8558  	if v, err := tp.ReadString(ctx); err != nil {
  8559  		return thrift.PrependError("error reading field 2: ", err)
  8560  	} else {
  8561  		p.Key = v
  8562  	}
  8563  	return nil
  8564  }
  8565  
  8566  func (p *HmSetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  8567  	_, _, size, err := tp.ReadMapBegin(ctx)
  8568  	if err != nil {
  8569  		return thrift.PrependError("error reading map begin: ", err)
  8570  	}
  8571  	tMap := make(map[string]string, size)
  8572  	p.Fields = tMap
  8573  	for i := 0; i < size; i++ {
  8574  		var _key186 string
  8575  		if v, err := tp.ReadString(ctx); err != nil {
  8576  			return thrift.PrependError("error reading field 0: ", err)
  8577  		} else {
  8578  			_key186 = v
  8579  		}
  8580  		var _val187 string
  8581  		if v, err := tp.ReadString(ctx); err != nil {
  8582  			return thrift.PrependError("error reading field 0: ", err)
  8583  		} else {
  8584  			_val187 = v
  8585  		}
  8586  		p.Fields[_key186] = _val187
  8587  	}
  8588  	if err := tp.ReadMapEnd(ctx); err != nil {
  8589  		return thrift.PrependError("error reading map end: ", err)
  8590  	}
  8591  	return nil
  8592  }
  8593  
  8594  func (p *HmSetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  8595  	if err := tp.WriteStructBegin(ctx, "HMSet_args"); err != nil {
  8596  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8597  	}
  8598  	if p != nil {
  8599  		if err := p.writeField1(ctx, tp); err != nil {
  8600  			return err
  8601  		}
  8602  		if err := p.writeField2(ctx, tp); err != nil {
  8603  			return err
  8604  		}
  8605  		if err := p.writeField3(ctx, tp); err != nil {
  8606  			return err
  8607  		}
  8608  	}
  8609  	if err := tp.WriteFieldStop(ctx); err != nil {
  8610  		return thrift.PrependError("write field stop error: ", err)
  8611  	}
  8612  	if err := tp.WriteStructEnd(ctx); err != nil {
  8613  		return thrift.PrependError("write struct stop error: ", err)
  8614  	}
  8615  	return nil
  8616  }
  8617  
  8618  func (p *HmSetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  8619  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  8620  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  8621  	}
  8622  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  8623  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  8624  	}
  8625  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8626  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  8627  	}
  8628  	return err
  8629  }
  8630  
  8631  func (p *HmSetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  8632  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  8633  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  8634  	}
  8635  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  8636  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  8637  	}
  8638  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8639  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  8640  	}
  8641  	return err
  8642  }
  8643  
  8644  func (p *HmSetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  8645  	if err := tp.WriteFieldBegin(ctx, "fields", thrift.MAP, 3); err != nil {
  8646  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fields: ", p), err)
  8647  	}
  8648  	if err := tp.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.Fields)); err != nil {
  8649  		return thrift.PrependError("error writing map begin: ", err)
  8650  	}
  8651  	for k, v := range p.Fields {
  8652  		if err := tp.WriteString(ctx, string(k)); err != nil {
  8653  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  8654  		}
  8655  		if err := tp.WriteString(ctx, string(v)); err != nil {
  8656  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  8657  		}
  8658  	}
  8659  	if err := tp.WriteMapEnd(ctx); err != nil {
  8660  		return thrift.PrependError("error writing map end: ", err)
  8661  	}
  8662  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8663  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fields: ", p), err)
  8664  	}
  8665  	return err
  8666  }
  8667  
  8668  func (p *HmSetArgs) String() string {
  8669  	if p == nil {
  8670  		return "<nil>"
  8671  	}
  8672  	return fmt.Sprintf("HmSetArgs(%+v)", *p)
  8673  }
  8674  
  8675  // Attributes:
  8676  //  - Success
  8677  type HmSetResult struct {
  8678  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  8679  }
  8680  
  8681  func NewHMSetResult() *HmSetResult {
  8682  	return &HmSetResult{}
  8683  }
  8684  
  8685  var HMSetResult_Success_DEFAULT *Response
  8686  
  8687  func (p *HmSetResult) GetSuccess() *Response {
  8688  	if !p.IsSetSuccess() {
  8689  		return HMSetResult_Success_DEFAULT
  8690  	}
  8691  	return p.Success
  8692  }
  8693  
  8694  func (p *HmSetResult) IsSetSuccess() bool {
  8695  	return p.Success != nil
  8696  }
  8697  
  8698  func (p *HmSetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  8699  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8700  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8701  	}
  8702  
  8703  	for {
  8704  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8705  		if err != nil {
  8706  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8707  		}
  8708  		if fieldTypeId == thrift.STOP {
  8709  			break
  8710  		}
  8711  		switch fieldId {
  8712  		case 0:
  8713  			if fieldTypeId == thrift.STRUCT {
  8714  				if err := p.ReadField0(ctx, tp); err != nil {
  8715  					return err
  8716  				}
  8717  			} else {
  8718  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8719  					return err
  8720  				}
  8721  			}
  8722  		default:
  8723  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8724  				return err
  8725  			}
  8726  		}
  8727  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8728  			return err
  8729  		}
  8730  	}
  8731  	if err := tp.ReadStructEnd(ctx); err != nil {
  8732  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8733  	}
  8734  	return nil
  8735  }
  8736  
  8737  func (p *HmSetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  8738  	p.Success = &Response{}
  8739  	if err := p.Success.Read(ctx, tp); err != nil {
  8740  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  8741  	}
  8742  	return nil
  8743  }
  8744  
  8745  func (p *HmSetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  8746  	if err := tp.WriteStructBegin(ctx, "HMSet_result"); err != nil {
  8747  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8748  	}
  8749  	if p != nil {
  8750  		if err := p.writeField0(ctx, tp); err != nil {
  8751  			return err
  8752  		}
  8753  	}
  8754  	if err := tp.WriteFieldStop(ctx); err != nil {
  8755  		return thrift.PrependError("write field stop error: ", err)
  8756  	}
  8757  	if err := tp.WriteStructEnd(ctx); err != nil {
  8758  		return thrift.PrependError("write struct stop error: ", err)
  8759  	}
  8760  	return nil
  8761  }
  8762  
  8763  func (p *HmSetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  8764  	if p.IsSetSuccess() {
  8765  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  8766  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  8767  		}
  8768  		if err := p.Success.Write(ctx, tp); err != nil {
  8769  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  8770  		}
  8771  		if err := tp.WriteFieldEnd(ctx); err != nil {
  8772  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  8773  		}
  8774  	}
  8775  	return err
  8776  }
  8777  
  8778  func (p *HmSetResult) String() string {
  8779  	if p == nil {
  8780  		return "<nil>"
  8781  	}
  8782  	return fmt.Sprintf("HmSetResult(%+v)", *p)
  8783  }
  8784  
  8785  // Attributes:
  8786  //  - Appid
  8787  //  - Key
  8788  //  - Fields
  8789  type HmSetBytesArgs struct {
  8790  	Appid  string            `thrift:"appid,1" db:"appid" json:"appid"`
  8791  	Key    string            `thrift:"key,2" db:"key" json:"key"`
  8792  	Fields map[string][]byte `thrift:"fields,3" db:"fields" json:"fields"`
  8793  }
  8794  
  8795  func NewHMSetBytesArgs() *HmSetBytesArgs {
  8796  	return &HmSetBytesArgs{}
  8797  }
  8798  
  8799  func (p *HmSetBytesArgs) GetAppid() string {
  8800  	return p.Appid
  8801  }
  8802  
  8803  func (p *HmSetBytesArgs) GetKey() string {
  8804  	return p.Key
  8805  }
  8806  
  8807  func (p *HmSetBytesArgs) GetFields() map[string][]byte {
  8808  	return p.Fields
  8809  }
  8810  
  8811  func (p *HmSetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  8812  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  8813  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  8814  	}
  8815  
  8816  	for {
  8817  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  8818  		if err != nil {
  8819  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  8820  		}
  8821  		if fieldTypeId == thrift.STOP {
  8822  			break
  8823  		}
  8824  		switch fieldId {
  8825  		case 1:
  8826  			if fieldTypeId == thrift.STRING {
  8827  				if err := p.ReadField1(ctx, tp); err != nil {
  8828  					return err
  8829  				}
  8830  			} else {
  8831  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8832  					return err
  8833  				}
  8834  			}
  8835  		case 2:
  8836  			if fieldTypeId == thrift.STRING {
  8837  				if err := p.ReadField2(ctx, tp); err != nil {
  8838  					return err
  8839  				}
  8840  			} else {
  8841  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8842  					return err
  8843  				}
  8844  			}
  8845  		case 3:
  8846  			if fieldTypeId == thrift.MAP {
  8847  				if err := p.ReadField3(ctx, tp); err != nil {
  8848  					return err
  8849  				}
  8850  			} else {
  8851  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8852  					return err
  8853  				}
  8854  			}
  8855  		default:
  8856  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  8857  				return err
  8858  			}
  8859  		}
  8860  		if err := tp.ReadFieldEnd(ctx); err != nil {
  8861  			return err
  8862  		}
  8863  	}
  8864  	if err := tp.ReadStructEnd(ctx); err != nil {
  8865  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  8866  	}
  8867  	return nil
  8868  }
  8869  
  8870  func (p *HmSetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  8871  	if v, err := tp.ReadString(ctx); err != nil {
  8872  		return thrift.PrependError("error reading field 1: ", err)
  8873  	} else {
  8874  		p.Appid = v
  8875  	}
  8876  	return nil
  8877  }
  8878  
  8879  func (p *HmSetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  8880  	if v, err := tp.ReadString(ctx); err != nil {
  8881  		return thrift.PrependError("error reading field 2: ", err)
  8882  	} else {
  8883  		p.Key = v
  8884  	}
  8885  	return nil
  8886  }
  8887  
  8888  func (p *HmSetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  8889  	_, _, size, err := tp.ReadMapBegin(ctx)
  8890  	if err != nil {
  8891  		return thrift.PrependError("error reading map begin: ", err)
  8892  	}
  8893  	tMap := make(map[string][]byte, size)
  8894  	p.Fields = tMap
  8895  	for i := 0; i < size; i++ {
  8896  		var _key188 string
  8897  		if v, err := tp.ReadString(ctx); err != nil {
  8898  			return thrift.PrependError("error reading field 0: ", err)
  8899  		} else {
  8900  			_key188 = v
  8901  		}
  8902  		var _val189 []byte
  8903  		if v, err := tp.ReadBinary(ctx); err != nil {
  8904  			return thrift.PrependError("error reading field 0: ", err)
  8905  		} else {
  8906  			_val189 = v
  8907  		}
  8908  		p.Fields[_key188] = _val189
  8909  	}
  8910  	if err := tp.ReadMapEnd(ctx); err != nil {
  8911  		return thrift.PrependError("error reading map end: ", err)
  8912  	}
  8913  	return nil
  8914  }
  8915  
  8916  func (p *HmSetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  8917  	if err := tp.WriteStructBegin(ctx, "HMSetBytes_args"); err != nil {
  8918  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  8919  	}
  8920  	if p != nil {
  8921  		if err := p.writeField1(ctx, tp); err != nil {
  8922  			return err
  8923  		}
  8924  		if err := p.writeField2(ctx, tp); err != nil {
  8925  			return err
  8926  		}
  8927  		if err := p.writeField3(ctx, tp); err != nil {
  8928  			return err
  8929  		}
  8930  	}
  8931  	if err := tp.WriteFieldStop(ctx); err != nil {
  8932  		return thrift.PrependError("write field stop error: ", err)
  8933  	}
  8934  	if err := tp.WriteStructEnd(ctx); err != nil {
  8935  		return thrift.PrependError("write struct stop error: ", err)
  8936  	}
  8937  	return nil
  8938  }
  8939  
  8940  func (p *HmSetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  8941  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  8942  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  8943  	}
  8944  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  8945  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  8946  	}
  8947  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8948  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  8949  	}
  8950  	return err
  8951  }
  8952  
  8953  func (p *HmSetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  8954  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  8955  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  8956  	}
  8957  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  8958  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  8959  	}
  8960  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8961  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  8962  	}
  8963  	return err
  8964  }
  8965  
  8966  func (p *HmSetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  8967  	if err := tp.WriteFieldBegin(ctx, "fields", thrift.MAP, 3); err != nil {
  8968  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fields: ", p), err)
  8969  	}
  8970  	if err := tp.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.Fields)); err != nil {
  8971  		return thrift.PrependError("error writing map begin: ", err)
  8972  	}
  8973  	for k, v := range p.Fields {
  8974  		if err := tp.WriteString(ctx, string(k)); err != nil {
  8975  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  8976  		}
  8977  		if err := tp.WriteBinary(ctx, v); err != nil {
  8978  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  8979  		}
  8980  	}
  8981  	if err := tp.WriteMapEnd(ctx); err != nil {
  8982  		return thrift.PrependError("error writing map end: ", err)
  8983  	}
  8984  	if err := tp.WriteFieldEnd(ctx); err != nil {
  8985  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fields: ", p), err)
  8986  	}
  8987  	return err
  8988  }
  8989  
  8990  func (p *HmSetBytesArgs) String() string {
  8991  	if p == nil {
  8992  		return "<nil>"
  8993  	}
  8994  	return fmt.Sprintf("HmSetBytesArgs(%+v)", *p)
  8995  }
  8996  
  8997  // Attributes:
  8998  //  - Success
  8999  type HmSetBytesResult struct {
  9000  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
  9001  }
  9002  
  9003  func NewRedisProxyHMSetBytesResult() *HmSetBytesResult {
  9004  	return &HmSetBytesResult{}
  9005  }
  9006  
  9007  var RedisProxyHMSetBytesResult_Success_DEFAULT *Response
  9008  
  9009  func (p *HmSetBytesResult) GetSuccess() *Response {
  9010  	if !p.IsSetSuccess() {
  9011  		return RedisProxyHMSetBytesResult_Success_DEFAULT
  9012  	}
  9013  	return p.Success
  9014  }
  9015  func (p *HmSetBytesResult) IsSetSuccess() bool {
  9016  	return p.Success != nil
  9017  }
  9018  
  9019  func (p *HmSetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  9020  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9021  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9022  	}
  9023  
  9024  	for {
  9025  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9026  		if err != nil {
  9027  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9028  		}
  9029  		if fieldTypeId == thrift.STOP {
  9030  			break
  9031  		}
  9032  		switch fieldId {
  9033  		case 0:
  9034  			if fieldTypeId == thrift.STRUCT {
  9035  				if err := p.ReadField0(ctx, tp); err != nil {
  9036  					return err
  9037  				}
  9038  			} else {
  9039  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9040  					return err
  9041  				}
  9042  			}
  9043  		default:
  9044  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9045  				return err
  9046  			}
  9047  		}
  9048  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9049  			return err
  9050  		}
  9051  	}
  9052  	if err := tp.ReadStructEnd(ctx); err != nil {
  9053  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9054  	}
  9055  	return nil
  9056  }
  9057  
  9058  func (p *HmSetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  9059  	p.Success = &Response{}
  9060  	if err := p.Success.Read(ctx, tp); err != nil {
  9061  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  9062  	}
  9063  	return nil
  9064  }
  9065  
  9066  func (p *HmSetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  9067  	if err := tp.WriteStructBegin(ctx, "HMSetBytes_result"); err != nil {
  9068  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9069  	}
  9070  	if p != nil {
  9071  		if err := p.writeField0(ctx, tp); err != nil {
  9072  			return err
  9073  		}
  9074  	}
  9075  	if err := tp.WriteFieldStop(ctx); err != nil {
  9076  		return thrift.PrependError("write field stop error: ", err)
  9077  	}
  9078  	if err := tp.WriteStructEnd(ctx); err != nil {
  9079  		return thrift.PrependError("write struct stop error: ", err)
  9080  	}
  9081  	return nil
  9082  }
  9083  
  9084  func (p *HmSetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  9085  	if p.IsSetSuccess() {
  9086  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  9087  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  9088  		}
  9089  		if err := p.Success.Write(ctx, tp); err != nil {
  9090  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  9091  		}
  9092  		if err := tp.WriteFieldEnd(ctx); err != nil {
  9093  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  9094  		}
  9095  	}
  9096  	return err
  9097  }
  9098  
  9099  func (p *HmSetBytesResult) String() string {
  9100  	if p == nil {
  9101  		return "<nil>"
  9102  	}
  9103  	return fmt.Sprintf("HmSetBytesResult(%+v)", *p)
  9104  }
  9105  
  9106  // Attributes:
  9107  //  - Appid
  9108  //  - Key
  9109  //  - Fields
  9110  type HmGetArgs struct {
  9111  	Appid  string   `thrift:"appid,1" db:"appid" json:"appid"`
  9112  	Key    string   `thrift:"key,2" db:"key" json:"key"`
  9113  	Fields []string `thrift:"fields,3" db:"fields" json:"fields"`
  9114  }
  9115  
  9116  func NewHMGetArgs() *HmGetArgs {
  9117  	return &HmGetArgs{}
  9118  }
  9119  
  9120  func (p *HmGetArgs) GetAppid() string {
  9121  	return p.Appid
  9122  }
  9123  
  9124  func (p *HmGetArgs) GetKey() string {
  9125  	return p.Key
  9126  }
  9127  
  9128  func (p *HmGetArgs) GetFields() []string {
  9129  	return p.Fields
  9130  }
  9131  func (p *HmGetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  9132  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9133  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9134  	}
  9135  
  9136  	for {
  9137  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9138  		if err != nil {
  9139  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9140  		}
  9141  		if fieldTypeId == thrift.STOP {
  9142  			break
  9143  		}
  9144  		switch fieldId {
  9145  		case 1:
  9146  			if fieldTypeId == thrift.STRING {
  9147  				if err := p.ReadField1(ctx, tp); err != nil {
  9148  					return err
  9149  				}
  9150  			} else {
  9151  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9152  					return err
  9153  				}
  9154  			}
  9155  		case 2:
  9156  			if fieldTypeId == thrift.STRING {
  9157  				if err := p.ReadField2(ctx, tp); err != nil {
  9158  					return err
  9159  				}
  9160  			} else {
  9161  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9162  					return err
  9163  				}
  9164  			}
  9165  		case 3:
  9166  			if fieldTypeId == thrift.LIST {
  9167  				if err := p.ReadField3(ctx, tp); err != nil {
  9168  					return err
  9169  				}
  9170  			} else {
  9171  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9172  					return err
  9173  				}
  9174  			}
  9175  		default:
  9176  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9177  				return err
  9178  			}
  9179  		}
  9180  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9181  			return err
  9182  		}
  9183  	}
  9184  	if err := tp.ReadStructEnd(ctx); err != nil {
  9185  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9186  	}
  9187  	return nil
  9188  }
  9189  
  9190  func (p *HmGetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  9191  	if v, err := tp.ReadString(ctx); err != nil {
  9192  		return thrift.PrependError("error reading field 1: ", err)
  9193  	} else {
  9194  		p.Appid = v
  9195  	}
  9196  	return nil
  9197  }
  9198  
  9199  func (p *HmGetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  9200  	if v, err := tp.ReadString(ctx); err != nil {
  9201  		return thrift.PrependError("error reading field 2: ", err)
  9202  	} else {
  9203  		p.Key = v
  9204  	}
  9205  	return nil
  9206  }
  9207  
  9208  func (p *HmGetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  9209  	_, size, err := tp.ReadListBegin(ctx)
  9210  	if err != nil {
  9211  		return thrift.PrependError("error reading list begin: ", err)
  9212  	}
  9213  	tSlice := make([]string, 0, size)
  9214  	p.Fields = tSlice
  9215  	for i := 0; i < size; i++ {
  9216  		var _elem190 string
  9217  		if v, err := tp.ReadString(ctx); err != nil {
  9218  			return thrift.PrependError("error reading field 0: ", err)
  9219  		} else {
  9220  			_elem190 = v
  9221  		}
  9222  		p.Fields = append(p.Fields, _elem190)
  9223  	}
  9224  	if err := tp.ReadListEnd(ctx); err != nil {
  9225  		return thrift.PrependError("error reading list end: ", err)
  9226  	}
  9227  	return nil
  9228  }
  9229  
  9230  func (p *HmGetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  9231  	if err := tp.WriteStructBegin(ctx, "HMGet_args"); err != nil {
  9232  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9233  	}
  9234  	if p != nil {
  9235  		if err := p.writeField1(ctx, tp); err != nil {
  9236  			return err
  9237  		}
  9238  		if err := p.writeField2(ctx, tp); err != nil {
  9239  			return err
  9240  		}
  9241  		if err := p.writeField3(ctx, tp); err != nil {
  9242  			return err
  9243  		}
  9244  	}
  9245  	if err := tp.WriteFieldStop(ctx); err != nil {
  9246  		return thrift.PrependError("write field stop error: ", err)
  9247  	}
  9248  	if err := tp.WriteStructEnd(ctx); err != nil {
  9249  		return thrift.PrependError("write struct stop error: ", err)
  9250  	}
  9251  	return nil
  9252  }
  9253  
  9254  func (p *HmGetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  9255  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  9256  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  9257  	}
  9258  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  9259  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  9260  	}
  9261  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9262  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  9263  	}
  9264  	return err
  9265  }
  9266  
  9267  func (p *HmGetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  9268  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  9269  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  9270  	}
  9271  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  9272  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  9273  	}
  9274  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9275  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  9276  	}
  9277  	return err
  9278  }
  9279  
  9280  func (p *HmGetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  9281  	if err := tp.WriteFieldBegin(ctx, "fields", thrift.LIST, 3); err != nil {
  9282  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fields: ", p), err)
  9283  	}
  9284  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Fields)); err != nil {
  9285  		return thrift.PrependError("error writing list begin: ", err)
  9286  	}
  9287  	for _, v := range p.Fields {
  9288  		if err := tp.WriteString(ctx, string(v)); err != nil {
  9289  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  9290  		}
  9291  	}
  9292  	if err := tp.WriteListEnd(ctx); err != nil {
  9293  		return thrift.PrependError("error writing list end: ", err)
  9294  	}
  9295  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9296  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fields: ", p), err)
  9297  	}
  9298  	return err
  9299  }
  9300  
  9301  func (p *HmGetArgs) String() string {
  9302  	if p == nil {
  9303  		return "<nil>"
  9304  	}
  9305  	return fmt.Sprintf("HmGetArgs(%+v)", *p)
  9306  }
  9307  
  9308  // Attributes:
  9309  //  - Success
  9310  type HMGetResult struct {
  9311  	Success *MResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  9312  }
  9313  
  9314  func NewRedisProxyHMGetResult() *HMGetResult {
  9315  	return &HMGetResult{}
  9316  }
  9317  
  9318  var RedisProxyHMGetResult_Success_DEFAULT *MResponse
  9319  
  9320  func (p *HMGetResult) GetSuccess() *MResponse {
  9321  	if !p.IsSetSuccess() {
  9322  		return RedisProxyHMGetResult_Success_DEFAULT
  9323  	}
  9324  	return p.Success
  9325  }
  9326  func (p *HMGetResult) IsSetSuccess() bool {
  9327  	return p.Success != nil
  9328  }
  9329  
  9330  func (p *HMGetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  9331  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9332  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9333  	}
  9334  
  9335  	for {
  9336  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9337  		if err != nil {
  9338  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9339  		}
  9340  		if fieldTypeId == thrift.STOP {
  9341  			break
  9342  		}
  9343  		switch fieldId {
  9344  		case 0:
  9345  			if fieldTypeId == thrift.STRUCT {
  9346  				if err := p.ReadField0(ctx, tp); err != nil {
  9347  					return err
  9348  				}
  9349  			} else {
  9350  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9351  					return err
  9352  				}
  9353  			}
  9354  		default:
  9355  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9356  				return err
  9357  			}
  9358  		}
  9359  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9360  			return err
  9361  		}
  9362  	}
  9363  	if err := tp.ReadStructEnd(ctx); err != nil {
  9364  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9365  	}
  9366  	return nil
  9367  }
  9368  
  9369  func (p *HMGetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  9370  	p.Success = &MResponse{}
  9371  	if err := p.Success.Read(ctx, tp); err != nil {
  9372  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  9373  	}
  9374  	return nil
  9375  }
  9376  
  9377  func (p *HMGetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  9378  	if err := tp.WriteStructBegin(ctx, "HMGet_result"); err != nil {
  9379  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9380  	}
  9381  	if p != nil {
  9382  		if err := p.writeField0(ctx, tp); err != nil {
  9383  			return err
  9384  		}
  9385  	}
  9386  	if err := tp.WriteFieldStop(ctx); err != nil {
  9387  		return thrift.PrependError("write field stop error: ", err)
  9388  	}
  9389  	if err := tp.WriteStructEnd(ctx); err != nil {
  9390  		return thrift.PrependError("write struct stop error: ", err)
  9391  	}
  9392  	return nil
  9393  }
  9394  
  9395  func (p *HMGetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  9396  	if p.IsSetSuccess() {
  9397  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  9398  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  9399  		}
  9400  		if err := p.Success.Write(ctx, tp); err != nil {
  9401  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  9402  		}
  9403  		if err := tp.WriteFieldEnd(ctx); err != nil {
  9404  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  9405  		}
  9406  	}
  9407  	return err
  9408  }
  9409  
  9410  func (p *HMGetResult) String() string {
  9411  	if p == nil {
  9412  		return "<nil>"
  9413  	}
  9414  	return fmt.Sprintf("HMGetResult(%+v)", *p)
  9415  }
  9416  
  9417  // Attributes:
  9418  //  - Appid
  9419  //  - Key
  9420  //  - Fields
  9421  type HMGetBytesArgs struct {
  9422  	Appid  string   `thrift:"appid,1" db:"appid" json:"appid"`
  9423  	Key    string   `thrift:"key,2" db:"key" json:"key"`
  9424  	Fields []string `thrift:"fields,3" db:"fields" json:"fields"`
  9425  }
  9426  
  9427  func NewHMGetBytesArgs() *HMGetBytesArgs {
  9428  	return &HMGetBytesArgs{}
  9429  }
  9430  
  9431  func (p *HMGetBytesArgs) GetAppid() string {
  9432  	return p.Appid
  9433  }
  9434  
  9435  func (p *HMGetBytesArgs) GetKey() string {
  9436  	return p.Key
  9437  }
  9438  
  9439  func (p *HMGetBytesArgs) GetFields() []string {
  9440  	return p.Fields
  9441  }
  9442  
  9443  func (p *HMGetBytesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  9444  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9445  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9446  	}
  9447  
  9448  	for {
  9449  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9450  		if err != nil {
  9451  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9452  		}
  9453  		if fieldTypeId == thrift.STOP {
  9454  			break
  9455  		}
  9456  		switch fieldId {
  9457  		case 1:
  9458  			if fieldTypeId == thrift.STRING {
  9459  				if err := p.ReadField1(ctx, tp); err != nil {
  9460  					return err
  9461  				}
  9462  			} else {
  9463  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9464  					return err
  9465  				}
  9466  			}
  9467  		case 2:
  9468  			if fieldTypeId == thrift.STRING {
  9469  				if err := p.ReadField2(ctx, tp); err != nil {
  9470  					return err
  9471  				}
  9472  			} else {
  9473  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9474  					return err
  9475  				}
  9476  			}
  9477  		case 3:
  9478  			if fieldTypeId == thrift.LIST {
  9479  				if err := p.ReadField3(ctx, tp); err != nil {
  9480  					return err
  9481  				}
  9482  			} else {
  9483  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9484  					return err
  9485  				}
  9486  			}
  9487  		default:
  9488  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9489  				return err
  9490  			}
  9491  		}
  9492  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9493  			return err
  9494  		}
  9495  	}
  9496  	if err := tp.ReadStructEnd(ctx); err != nil {
  9497  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9498  	}
  9499  	return nil
  9500  }
  9501  
  9502  func (p *HMGetBytesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  9503  	if v, err := tp.ReadString(ctx); err != nil {
  9504  		return thrift.PrependError("error reading field 1: ", err)
  9505  	} else {
  9506  		p.Appid = v
  9507  	}
  9508  	return nil
  9509  }
  9510  
  9511  func (p *HMGetBytesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  9512  	if v, err := tp.ReadString(ctx); err != nil {
  9513  		return thrift.PrependError("error reading field 2: ", err)
  9514  	} else {
  9515  		p.Key = v
  9516  	}
  9517  	return nil
  9518  }
  9519  
  9520  func (p *HMGetBytesArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
  9521  	_, size, err := tp.ReadListBegin(ctx)
  9522  	if err != nil {
  9523  		return thrift.PrependError("error reading list begin: ", err)
  9524  	}
  9525  	tSlice := make([]string, 0, size)
  9526  	p.Fields = tSlice
  9527  	for i := 0; i < size; i++ {
  9528  		var _elem191 string
  9529  		if v, err := tp.ReadString(ctx); err != nil {
  9530  			return thrift.PrependError("error reading field 0: ", err)
  9531  		} else {
  9532  			_elem191 = v
  9533  		}
  9534  		p.Fields = append(p.Fields, _elem191)
  9535  	}
  9536  	if err := tp.ReadListEnd(ctx); err != nil {
  9537  		return thrift.PrependError("error reading list end: ", err)
  9538  	}
  9539  	return nil
  9540  }
  9541  
  9542  func (p *HMGetBytesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  9543  	if err := tp.WriteStructBegin(ctx, "HMGetBytes_args"); err != nil {
  9544  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9545  	}
  9546  	if p != nil {
  9547  		if err := p.writeField1(ctx, tp); err != nil {
  9548  			return err
  9549  		}
  9550  		if err := p.writeField2(ctx, tp); err != nil {
  9551  			return err
  9552  		}
  9553  		if err := p.writeField3(ctx, tp); err != nil {
  9554  			return err
  9555  		}
  9556  	}
  9557  	if err := tp.WriteFieldStop(ctx); err != nil {
  9558  		return thrift.PrependError("write field stop error: ", err)
  9559  	}
  9560  	if err := tp.WriteStructEnd(ctx); err != nil {
  9561  		return thrift.PrependError("write struct stop error: ", err)
  9562  	}
  9563  	return nil
  9564  }
  9565  
  9566  func (p *HMGetBytesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  9567  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  9568  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  9569  	}
  9570  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  9571  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  9572  	}
  9573  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9574  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  9575  	}
  9576  	return err
  9577  }
  9578  
  9579  func (p *HMGetBytesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  9580  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  9581  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  9582  	}
  9583  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  9584  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  9585  	}
  9586  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9587  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  9588  	}
  9589  	return err
  9590  }
  9591  
  9592  func (p *HMGetBytesArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
  9593  	if err := tp.WriteFieldBegin(ctx, "fields", thrift.LIST, 3); err != nil {
  9594  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fields: ", p), err)
  9595  	}
  9596  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Fields)); err != nil {
  9597  		return thrift.PrependError("error writing list begin: ", err)
  9598  	}
  9599  	for _, v := range p.Fields {
  9600  		if err := tp.WriteString(ctx, string(v)); err != nil {
  9601  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
  9602  		}
  9603  	}
  9604  	if err := tp.WriteListEnd(ctx); err != nil {
  9605  		return thrift.PrependError("error writing list end: ", err)
  9606  	}
  9607  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9608  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fields: ", p), err)
  9609  	}
  9610  	return err
  9611  }
  9612  
  9613  func (p *HMGetBytesArgs) String() string {
  9614  	if p == nil {
  9615  		return "<nil>"
  9616  	}
  9617  	return fmt.Sprintf("HMGetBytesArgs(%+v)", *p)
  9618  }
  9619  
  9620  // Attributes:
  9621  //  - Success
  9622  type HMGetBytesResult struct {
  9623  	Success *MBytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  9624  }
  9625  
  9626  func NewHMGetBytesResult() *HMGetBytesResult {
  9627  	return &HMGetBytesResult{}
  9628  }
  9629  
  9630  var HMGetBytesResult_Success_DEFAULT *MBytesResponse
  9631  
  9632  func (p *HMGetBytesResult) GetSuccess() *MBytesResponse {
  9633  	if !p.IsSetSuccess() {
  9634  		return HMGetBytesResult_Success_DEFAULT
  9635  	}
  9636  	return p.Success
  9637  }
  9638  
  9639  func (p *HMGetBytesResult) IsSetSuccess() bool {
  9640  	return p.Success != nil
  9641  }
  9642  
  9643  func (p *HMGetBytesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  9644  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9645  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9646  	}
  9647  
  9648  	for {
  9649  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9650  		if err != nil {
  9651  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9652  		}
  9653  		if fieldTypeId == thrift.STOP {
  9654  			break
  9655  		}
  9656  		switch fieldId {
  9657  		case 0:
  9658  			if fieldTypeId == thrift.STRUCT {
  9659  				if err := p.ReadField0(ctx, tp); err != nil {
  9660  					return err
  9661  				}
  9662  			} else {
  9663  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9664  					return err
  9665  				}
  9666  			}
  9667  		default:
  9668  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9669  				return err
  9670  			}
  9671  		}
  9672  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9673  			return err
  9674  		}
  9675  	}
  9676  	if err := tp.ReadStructEnd(ctx); err != nil {
  9677  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9678  	}
  9679  	return nil
  9680  }
  9681  
  9682  func (p *HMGetBytesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  9683  	p.Success = &MBytesResponse{}
  9684  	if err := p.Success.Read(ctx, tp); err != nil {
  9685  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  9686  	}
  9687  	return nil
  9688  }
  9689  
  9690  func (p *HMGetBytesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  9691  	if err := tp.WriteStructBegin(ctx, "HMGetBytes_result"); err != nil {
  9692  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9693  	}
  9694  	if p != nil {
  9695  		if err := p.writeField0(ctx, tp); err != nil {
  9696  			return err
  9697  		}
  9698  	}
  9699  	if err := tp.WriteFieldStop(ctx); err != nil {
  9700  		return thrift.PrependError("write field stop error: ", err)
  9701  	}
  9702  	if err := tp.WriteStructEnd(ctx); err != nil {
  9703  		return thrift.PrependError("write struct stop error: ", err)
  9704  	}
  9705  	return nil
  9706  }
  9707  
  9708  func (p *HMGetBytesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  9709  	if p.IsSetSuccess() {
  9710  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  9711  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  9712  		}
  9713  		if err := p.Success.Write(ctx, tp); err != nil {
  9714  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  9715  		}
  9716  		if err := tp.WriteFieldEnd(ctx); err != nil {
  9717  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  9718  		}
  9719  	}
  9720  	return err
  9721  }
  9722  
  9723  func (p *HMGetBytesResult) String() string {
  9724  	if p == nil {
  9725  		return "<nil>"
  9726  	}
  9727  	return fmt.Sprintf("HMGetBytesResult(%+v)", *p)
  9728  }
  9729  
  9730  // Attributes:
  9731  //  - Appid
  9732  //  - Key
  9733  type HGetAllArgs struct {
  9734  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  9735  	Key   string `thrift:"key,2" db:"key" json:"key"`
  9736  }
  9737  
  9738  func NewHGetAllArgs() *HGetAllArgs {
  9739  	return &HGetAllArgs{}
  9740  }
  9741  
  9742  func (p *HGetAllArgs) GetAppid() string {
  9743  	return p.Appid
  9744  }
  9745  
  9746  func (p *HGetAllArgs) GetKey() string {
  9747  	return p.Key
  9748  }
  9749  
  9750  func (p *HGetAllArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
  9751  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9752  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9753  	}
  9754  
  9755  	for {
  9756  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9757  		if err != nil {
  9758  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9759  		}
  9760  		if fieldTypeId == thrift.STOP {
  9761  			break
  9762  		}
  9763  		switch fieldId {
  9764  		case 1:
  9765  			if fieldTypeId == thrift.STRING {
  9766  				if err := p.ReadField1(ctx, tp); err != nil {
  9767  					return err
  9768  				}
  9769  			} else {
  9770  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9771  					return err
  9772  				}
  9773  			}
  9774  		case 2:
  9775  			if fieldTypeId == thrift.STRING {
  9776  				if err := p.ReadField2(ctx, tp); err != nil {
  9777  					return err
  9778  				}
  9779  			} else {
  9780  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9781  					return err
  9782  				}
  9783  			}
  9784  		default:
  9785  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9786  				return err
  9787  			}
  9788  		}
  9789  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9790  			return err
  9791  		}
  9792  	}
  9793  	if err := tp.ReadStructEnd(ctx); err != nil {
  9794  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9795  	}
  9796  	return nil
  9797  }
  9798  
  9799  func (p *HGetAllArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
  9800  	if v, err := tp.ReadString(ctx); err != nil {
  9801  		return thrift.PrependError("error reading field 1: ", err)
  9802  	} else {
  9803  		p.Appid = v
  9804  	}
  9805  	return nil
  9806  }
  9807  
  9808  func (p *HGetAllArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
  9809  	if v, err := tp.ReadString(ctx); err != nil {
  9810  		return thrift.PrependError("error reading field 2: ", err)
  9811  	} else {
  9812  		p.Key = v
  9813  	}
  9814  	return nil
  9815  }
  9816  
  9817  func (p *HGetAllArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
  9818  	if err := tp.WriteStructBegin(ctx, "HGetAll_args"); err != nil {
  9819  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9820  	}
  9821  	if p != nil {
  9822  		if err := p.writeField1(ctx, tp); err != nil {
  9823  			return err
  9824  		}
  9825  		if err := p.writeField2(ctx, tp); err != nil {
  9826  			return err
  9827  		}
  9828  	}
  9829  	if err := tp.WriteFieldStop(ctx); err != nil {
  9830  		return thrift.PrependError("write field stop error: ", err)
  9831  	}
  9832  	if err := tp.WriteStructEnd(ctx); err != nil {
  9833  		return thrift.PrependError("write struct stop error: ", err)
  9834  	}
  9835  	return nil
  9836  }
  9837  
  9838  func (p *HGetAllArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
  9839  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
  9840  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
  9841  	}
  9842  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
  9843  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
  9844  	}
  9845  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9846  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
  9847  	}
  9848  	return err
  9849  }
  9850  
  9851  func (p *HGetAllArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
  9852  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
  9853  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
  9854  	}
  9855  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
  9856  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
  9857  	}
  9858  	if err := tp.WriteFieldEnd(ctx); err != nil {
  9859  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
  9860  	}
  9861  	return err
  9862  }
  9863  
  9864  func (p *HGetAllArgs) String() string {
  9865  	if p == nil {
  9866  		return "<nil>"
  9867  	}
  9868  	return fmt.Sprintf("HGetAllArgs(%+v)", *p)
  9869  }
  9870  
  9871  // Attributes:
  9872  //  - Success
  9873  type HGetAllResult struct {
  9874  	Success *MResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
  9875  }
  9876  
  9877  func NewHGetAllResult() *HGetAllResult {
  9878  	return &HGetAllResult{}
  9879  }
  9880  
  9881  var HGetAllResult_Success_DEFAULT *MResponse
  9882  
  9883  func (p *HGetAllResult) GetSuccess() *MResponse {
  9884  	if !p.IsSetSuccess() {
  9885  		return HGetAllResult_Success_DEFAULT
  9886  	}
  9887  	return p.Success
  9888  }
  9889  func (p *HGetAllResult) IsSetSuccess() bool {
  9890  	return p.Success != nil
  9891  }
  9892  
  9893  func (p *HGetAllResult) Read(ctx context.Context, tp thrift.TProtocol) error {
  9894  	if _, err := tp.ReadStructBegin(ctx); err != nil {
  9895  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  9896  	}
  9897  
  9898  	for {
  9899  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
  9900  		if err != nil {
  9901  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
  9902  		}
  9903  		if fieldTypeId == thrift.STOP {
  9904  			break
  9905  		}
  9906  		switch fieldId {
  9907  		case 0:
  9908  			if fieldTypeId == thrift.STRUCT {
  9909  				if err := p.ReadField0(ctx, tp); err != nil {
  9910  					return err
  9911  				}
  9912  			} else {
  9913  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9914  					return err
  9915  				}
  9916  			}
  9917  		default:
  9918  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
  9919  				return err
  9920  			}
  9921  		}
  9922  		if err := tp.ReadFieldEnd(ctx); err != nil {
  9923  			return err
  9924  		}
  9925  	}
  9926  	if err := tp.ReadStructEnd(ctx); err != nil {
  9927  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  9928  	}
  9929  	return nil
  9930  }
  9931  
  9932  func (p *HGetAllResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
  9933  	p.Success = &MResponse{}
  9934  	if err := p.Success.Read(ctx, tp); err != nil {
  9935  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  9936  	}
  9937  	return nil
  9938  }
  9939  
  9940  func (p *HGetAllResult) Write(ctx context.Context, tp thrift.TProtocol) error {
  9941  	if err := tp.WriteStructBegin(ctx, "HGetAll_result"); err != nil {
  9942  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
  9943  	}
  9944  	if p != nil {
  9945  		if err := p.writeField0(ctx, tp); err != nil {
  9946  			return err
  9947  		}
  9948  	}
  9949  	if err := tp.WriteFieldStop(ctx); err != nil {
  9950  		return thrift.PrependError("write field stop error: ", err)
  9951  	}
  9952  	if err := tp.WriteStructEnd(ctx); err != nil {
  9953  		return thrift.PrependError("write struct stop error: ", err)
  9954  	}
  9955  	return nil
  9956  }
  9957  
  9958  func (p *HGetAllResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
  9959  	if p.IsSetSuccess() {
  9960  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
  9961  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
  9962  		}
  9963  		if err := p.Success.Write(ctx, tp); err != nil {
  9964  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
  9965  		}
  9966  		if err := tp.WriteFieldEnd(ctx); err != nil {
  9967  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
  9968  		}
  9969  	}
  9970  	return err
  9971  }
  9972  
  9973  func (p *HGetAllResult) String() string {
  9974  	if p == nil {
  9975  		return "<nil>"
  9976  	}
  9977  	return fmt.Sprintf("HGetAllResult(%+v)", *p)
  9978  }
  9979  
  9980  // Attributes:
  9981  //  - Appid
  9982  //  - Key
  9983  //  - Field
  9984  type HDelArgs struct {
  9985  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
  9986  	Key   string `thrift:"key,2" db:"key" json:"key"`
  9987  	Field string `thrift:"field,3" db:"field" json:"field"`
  9988  }
  9989  
  9990  func NewHDelArgs() *HDelArgs {
  9991  	return &HDelArgs{}
  9992  }
  9993  
  9994  func (p *HDelArgs) GetAppid() string {
  9995  	return p.Appid
  9996  }
  9997  
  9998  func (p *HDelArgs) GetKey() string {
  9999  	return p.Key
 10000  }
 10001  
 10002  func (p *HDelArgs) GetField() string {
 10003  	return p.Field
 10004  }
 10005  
 10006  func (p *HDelArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 10007  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10008  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10009  	}
 10010  
 10011  	for {
 10012  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10013  		if err != nil {
 10014  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10015  		}
 10016  		if fieldTypeId == thrift.STOP {
 10017  			break
 10018  		}
 10019  		switch fieldId {
 10020  		case 1:
 10021  			if fieldTypeId == thrift.STRING {
 10022  				if err := p.ReadField1(ctx, tp); err != nil {
 10023  					return err
 10024  				}
 10025  			} else {
 10026  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10027  					return err
 10028  				}
 10029  			}
 10030  		case 2:
 10031  			if fieldTypeId == thrift.STRING {
 10032  				if err := p.ReadField2(ctx, tp); err != nil {
 10033  					return err
 10034  				}
 10035  			} else {
 10036  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10037  					return err
 10038  				}
 10039  			}
 10040  		case 3:
 10041  			if fieldTypeId == thrift.STRING {
 10042  				if err := p.ReadField3(ctx, tp); err != nil {
 10043  					return err
 10044  				}
 10045  			} else {
 10046  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10047  					return err
 10048  				}
 10049  			}
 10050  		default:
 10051  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10052  				return err
 10053  			}
 10054  		}
 10055  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10056  			return err
 10057  		}
 10058  	}
 10059  	if err := tp.ReadStructEnd(ctx); err != nil {
 10060  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10061  	}
 10062  	return nil
 10063  }
 10064  
 10065  func (p *HDelArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 10066  	if v, err := tp.ReadString(ctx); err != nil {
 10067  		return thrift.PrependError("error reading field 1: ", err)
 10068  	} else {
 10069  		p.Appid = v
 10070  	}
 10071  	return nil
 10072  }
 10073  
 10074  func (p *HDelArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 10075  	if v, err := tp.ReadString(ctx); err != nil {
 10076  		return thrift.PrependError("error reading field 2: ", err)
 10077  	} else {
 10078  		p.Key = v
 10079  	}
 10080  	return nil
 10081  }
 10082  
 10083  func (p *HDelArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 10084  	if v, err := tp.ReadString(ctx); err != nil {
 10085  		return thrift.PrependError("error reading field 3: ", err)
 10086  	} else {
 10087  		p.Field = v
 10088  	}
 10089  	return nil
 10090  }
 10091  
 10092  func (p *HDelArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 10093  	if err := tp.WriteStructBegin(ctx, "HDel_args"); err != nil {
 10094  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10095  	}
 10096  	if p != nil {
 10097  		if err := p.writeField1(ctx, tp); err != nil {
 10098  			return err
 10099  		}
 10100  		if err := p.writeField2(ctx, tp); err != nil {
 10101  			return err
 10102  		}
 10103  		if err := p.writeField3(ctx, tp); err != nil {
 10104  			return err
 10105  		}
 10106  	}
 10107  	if err := tp.WriteFieldStop(ctx); err != nil {
 10108  		return thrift.PrependError("write field stop error: ", err)
 10109  	}
 10110  	if err := tp.WriteStructEnd(ctx); err != nil {
 10111  		return thrift.PrependError("write struct stop error: ", err)
 10112  	}
 10113  	return nil
 10114  }
 10115  
 10116  func (p *HDelArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 10117  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 10118  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 10119  	}
 10120  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 10121  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 10122  	}
 10123  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10124  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 10125  	}
 10126  	return err
 10127  }
 10128  
 10129  func (p *HDelArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 10130  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 10131  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 10132  	}
 10133  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 10134  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 10135  	}
 10136  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10137  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 10138  	}
 10139  	return err
 10140  }
 10141  
 10142  func (p *HDelArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 10143  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
 10144  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
 10145  	}
 10146  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
 10147  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
 10148  	}
 10149  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10150  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
 10151  	}
 10152  	return err
 10153  }
 10154  
 10155  func (p *HDelArgs) String() string {
 10156  	if p == nil {
 10157  		return "<nil>"
 10158  	}
 10159  	return fmt.Sprintf("HDelArgs(%+v)", *p)
 10160  }
 10161  
 10162  // Attributes:
 10163  //  - Success
 10164  type HDelResult struct {
 10165  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 10166  }
 10167  
 10168  func NewHDelResult() *HDelResult {
 10169  	return &HDelResult{}
 10170  }
 10171  
 10172  var HDelResult_Success_DEFAULT *IntResponse
 10173  
 10174  func (p *HDelResult) GetSuccess() *IntResponse {
 10175  	if !p.IsSetSuccess() {
 10176  		return HDelResult_Success_DEFAULT
 10177  	}
 10178  	return p.Success
 10179  }
 10180  
 10181  func (p *HDelResult) IsSetSuccess() bool {
 10182  	return p.Success != nil
 10183  }
 10184  
 10185  func (p *HDelResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 10186  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10187  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10188  	}
 10189  
 10190  	for {
 10191  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10192  		if err != nil {
 10193  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10194  		}
 10195  		if fieldTypeId == thrift.STOP {
 10196  			break
 10197  		}
 10198  		switch fieldId {
 10199  		case 0:
 10200  			if fieldTypeId == thrift.STRUCT {
 10201  				if err := p.ReadField0(ctx, tp); err != nil {
 10202  					return err
 10203  				}
 10204  			} else {
 10205  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10206  					return err
 10207  				}
 10208  			}
 10209  		default:
 10210  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10211  				return err
 10212  			}
 10213  		}
 10214  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10215  			return err
 10216  		}
 10217  	}
 10218  	if err := tp.ReadStructEnd(ctx); err != nil {
 10219  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10220  	}
 10221  	return nil
 10222  }
 10223  
 10224  func (p *HDelResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 10225  	p.Success = &IntResponse{}
 10226  	if err := p.Success.Read(ctx, tp); err != nil {
 10227  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 10228  	}
 10229  	return nil
 10230  }
 10231  
 10232  func (p *HDelResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 10233  	if err := tp.WriteStructBegin(ctx, "HDel_result"); err != nil {
 10234  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10235  	}
 10236  	if p != nil {
 10237  		if err := p.writeField0(ctx, tp); err != nil {
 10238  			return err
 10239  		}
 10240  	}
 10241  	if err := tp.WriteFieldStop(ctx); err != nil {
 10242  		return thrift.PrependError("write field stop error: ", err)
 10243  	}
 10244  	if err := tp.WriteStructEnd(ctx); err != nil {
 10245  		return thrift.PrependError("write struct stop error: ", err)
 10246  	}
 10247  	return nil
 10248  }
 10249  
 10250  func (p *HDelResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 10251  	if p.IsSetSuccess() {
 10252  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 10253  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 10254  		}
 10255  		if err := p.Success.Write(ctx, tp); err != nil {
 10256  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 10257  		}
 10258  		if err := tp.WriteFieldEnd(ctx); err != nil {
 10259  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 10260  		}
 10261  	}
 10262  	return err
 10263  }
 10264  
 10265  func (p *HDelResult) String() string {
 10266  	if p == nil {
 10267  		return "<nil>"
 10268  	}
 10269  	return fmt.Sprintf("HDelResult(%+v)", *p)
 10270  }
 10271  
 10272  // Attributes:
 10273  //  - Appid
 10274  //  - Key
 10275  //  - Fields
 10276  type MhDelArgs struct {
 10277  	Appid  string   `thrift:"appid,1" db:"appid" json:"appid"`
 10278  	Key    string   `thrift:"key,2" db:"key" json:"key"`
 10279  	Fields []string `thrift:"fields,3" db:"fields" json:"fields"`
 10280  }
 10281  
 10282  func NewMHDelArgs() *MhDelArgs {
 10283  	return &MhDelArgs{}
 10284  }
 10285  
 10286  func (p *MhDelArgs) GetAppid() string {
 10287  	return p.Appid
 10288  }
 10289  
 10290  func (p *MhDelArgs) GetKey() string {
 10291  	return p.Key
 10292  }
 10293  
 10294  func (p *MhDelArgs) GetFields() []string {
 10295  	return p.Fields
 10296  }
 10297  
 10298  func (p *MhDelArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 10299  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10300  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10301  	}
 10302  
 10303  	for {
 10304  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10305  		if err != nil {
 10306  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10307  		}
 10308  		if fieldTypeId == thrift.STOP {
 10309  			break
 10310  		}
 10311  		switch fieldId {
 10312  		case 1:
 10313  			if fieldTypeId == thrift.STRING {
 10314  				if err := p.ReadField1(ctx, tp); err != nil {
 10315  					return err
 10316  				}
 10317  			} else {
 10318  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10319  					return err
 10320  				}
 10321  			}
 10322  		case 2:
 10323  			if fieldTypeId == thrift.STRING {
 10324  				if err := p.ReadField2(ctx, tp); err != nil {
 10325  					return err
 10326  				}
 10327  			} else {
 10328  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10329  					return err
 10330  				}
 10331  			}
 10332  		case 3:
 10333  			if fieldTypeId == thrift.LIST {
 10334  				if err := p.ReadField3(ctx, tp); err != nil {
 10335  					return err
 10336  				}
 10337  			} else {
 10338  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10339  					return err
 10340  				}
 10341  			}
 10342  		default:
 10343  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10344  				return err
 10345  			}
 10346  		}
 10347  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10348  			return err
 10349  		}
 10350  	}
 10351  	if err := tp.ReadStructEnd(ctx); err != nil {
 10352  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10353  	}
 10354  	return nil
 10355  }
 10356  
 10357  func (p *MhDelArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 10358  	if v, err := tp.ReadString(ctx); err != nil {
 10359  		return thrift.PrependError("error reading field 1: ", err)
 10360  	} else {
 10361  		p.Appid = v
 10362  	}
 10363  	return nil
 10364  }
 10365  
 10366  func (p *MhDelArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 10367  	if v, err := tp.ReadString(ctx); err != nil {
 10368  		return thrift.PrependError("error reading field 2: ", err)
 10369  	} else {
 10370  		p.Key = v
 10371  	}
 10372  	return nil
 10373  }
 10374  
 10375  func (p *MhDelArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 10376  	_, size, err := tp.ReadListBegin(ctx)
 10377  	if err != nil {
 10378  		return thrift.PrependError("error reading list begin: ", err)
 10379  	}
 10380  	tSlice := make([]string, 0, size)
 10381  	p.Fields = tSlice
 10382  	for i := 0; i < size; i++ {
 10383  		var _elem192 string
 10384  		if v, err := tp.ReadString(ctx); err != nil {
 10385  			return thrift.PrependError("error reading field 0: ", err)
 10386  		} else {
 10387  			_elem192 = v
 10388  		}
 10389  		p.Fields = append(p.Fields, _elem192)
 10390  	}
 10391  	if err := tp.ReadListEnd(ctx); err != nil {
 10392  		return thrift.PrependError("error reading list end: ", err)
 10393  	}
 10394  	return nil
 10395  }
 10396  
 10397  func (p *MhDelArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 10398  	if err := tp.WriteStructBegin(ctx, "MHDel_args"); err != nil {
 10399  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10400  	}
 10401  	if p != nil {
 10402  		if err := p.writeField1(ctx, tp); err != nil {
 10403  			return err
 10404  		}
 10405  		if err := p.writeField2(ctx, tp); err != nil {
 10406  			return err
 10407  		}
 10408  		if err := p.writeField3(ctx, tp); err != nil {
 10409  			return err
 10410  		}
 10411  	}
 10412  	if err := tp.WriteFieldStop(ctx); err != nil {
 10413  		return thrift.PrependError("write field stop error: ", err)
 10414  	}
 10415  	if err := tp.WriteStructEnd(ctx); err != nil {
 10416  		return thrift.PrependError("write struct stop error: ", err)
 10417  	}
 10418  	return nil
 10419  }
 10420  
 10421  func (p *MhDelArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 10422  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 10423  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 10424  	}
 10425  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 10426  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 10427  	}
 10428  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10429  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 10430  	}
 10431  	return err
 10432  }
 10433  
 10434  func (p *MhDelArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 10435  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 10436  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 10437  	}
 10438  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 10439  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 10440  	}
 10441  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10442  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 10443  	}
 10444  	return err
 10445  }
 10446  
 10447  func (p *MhDelArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 10448  	if err := tp.WriteFieldBegin(ctx, "fields", thrift.LIST, 3); err != nil {
 10449  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:fields: ", p), err)
 10450  	}
 10451  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Fields)); err != nil {
 10452  		return thrift.PrependError("error writing list begin: ", err)
 10453  	}
 10454  	for _, v := range p.Fields {
 10455  		if err := tp.WriteString(ctx, string(v)); err != nil {
 10456  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 10457  		}
 10458  	}
 10459  	if err := tp.WriteListEnd(ctx); err != nil {
 10460  		return thrift.PrependError("error writing list end: ", err)
 10461  	}
 10462  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10463  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:fields: ", p), err)
 10464  	}
 10465  	return err
 10466  }
 10467  
 10468  func (p *MhDelArgs) String() string {
 10469  	if p == nil {
 10470  		return "<nil>"
 10471  	}
 10472  	return fmt.Sprintf("MhDelArgs(%+v)", *p)
 10473  }
 10474  
 10475  // Attributes:
 10476  //  - Success
 10477  type MhDelResult struct {
 10478  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 10479  }
 10480  
 10481  func NewMHDelResult() *MhDelResult {
 10482  	return &MhDelResult{}
 10483  }
 10484  
 10485  var MHDelResult_Success_DEFAULT *IntResponse
 10486  
 10487  func (p *MhDelResult) GetSuccess() *IntResponse {
 10488  	if !p.IsSetSuccess() {
 10489  		return MHDelResult_Success_DEFAULT
 10490  	}
 10491  	return p.Success
 10492  }
 10493  
 10494  func (p *MhDelResult) IsSetSuccess() bool {
 10495  	return p.Success != nil
 10496  }
 10497  
 10498  func (p *MhDelResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 10499  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10500  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10501  	}
 10502  
 10503  	for {
 10504  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10505  		if err != nil {
 10506  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10507  		}
 10508  		if fieldTypeId == thrift.STOP {
 10509  			break
 10510  		}
 10511  		switch fieldId {
 10512  		case 0:
 10513  			if fieldTypeId == thrift.STRUCT {
 10514  				if err := p.ReadField0(ctx, tp); err != nil {
 10515  					return err
 10516  				}
 10517  			} else {
 10518  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10519  					return err
 10520  				}
 10521  			}
 10522  		default:
 10523  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10524  				return err
 10525  			}
 10526  		}
 10527  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10528  			return err
 10529  		}
 10530  	}
 10531  	if err := tp.ReadStructEnd(ctx); err != nil {
 10532  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10533  	}
 10534  	return nil
 10535  }
 10536  
 10537  func (p *MhDelResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 10538  	p.Success = &IntResponse{}
 10539  	if err := p.Success.Read(ctx, tp); err != nil {
 10540  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 10541  	}
 10542  	return nil
 10543  }
 10544  
 10545  func (p *MhDelResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 10546  	if err := tp.WriteStructBegin(ctx, "MHDel_result"); err != nil {
 10547  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10548  	}
 10549  	if p != nil {
 10550  		if err := p.writeField0(ctx, tp); err != nil {
 10551  			return err
 10552  		}
 10553  	}
 10554  	if err := tp.WriteFieldStop(ctx); err != nil {
 10555  		return thrift.PrependError("write field stop error: ", err)
 10556  	}
 10557  	if err := tp.WriteStructEnd(ctx); err != nil {
 10558  		return thrift.PrependError("write struct stop error: ", err)
 10559  	}
 10560  	return nil
 10561  }
 10562  
 10563  func (p *MhDelResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 10564  	if p.IsSetSuccess() {
 10565  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 10566  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 10567  		}
 10568  		if err := p.Success.Write(ctx, tp); err != nil {
 10569  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 10570  		}
 10571  		if err := tp.WriteFieldEnd(ctx); err != nil {
 10572  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 10573  		}
 10574  	}
 10575  	return err
 10576  }
 10577  
 10578  func (p *MhDelResult) String() string {
 10579  	if p == nil {
 10580  		return "<nil>"
 10581  	}
 10582  	return fmt.Sprintf("MhDelResult(%+v)", *p)
 10583  }
 10584  
 10585  // Attributes:
 10586  //  - Appid
 10587  //  - Key
 10588  type HKeysArgs struct {
 10589  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 10590  	Key   string `thrift:"key,2" db:"key" json:"key"`
 10591  }
 10592  
 10593  func NewHKeysArgs() *HKeysArgs {
 10594  	return &HKeysArgs{}
 10595  }
 10596  
 10597  func (p *HKeysArgs) GetAppid() string {
 10598  	return p.Appid
 10599  }
 10600  
 10601  func (p *HKeysArgs) GetKey() string {
 10602  	return p.Key
 10603  }
 10604  func (p *HKeysArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 10605  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10606  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10607  	}
 10608  
 10609  	for {
 10610  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10611  		if err != nil {
 10612  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10613  		}
 10614  		if fieldTypeId == thrift.STOP {
 10615  			break
 10616  		}
 10617  		switch fieldId {
 10618  		case 1:
 10619  			if fieldTypeId == thrift.STRING {
 10620  				if err := p.ReadField1(ctx, tp); err != nil {
 10621  					return err
 10622  				}
 10623  			} else {
 10624  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10625  					return err
 10626  				}
 10627  			}
 10628  		case 2:
 10629  			if fieldTypeId == thrift.STRING {
 10630  				if err := p.ReadField2(ctx, tp); err != nil {
 10631  					return err
 10632  				}
 10633  			} else {
 10634  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10635  					return err
 10636  				}
 10637  			}
 10638  		default:
 10639  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10640  				return err
 10641  			}
 10642  		}
 10643  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10644  			return err
 10645  		}
 10646  	}
 10647  	if err := tp.ReadStructEnd(ctx); err != nil {
 10648  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10649  	}
 10650  	return nil
 10651  }
 10652  
 10653  func (p *HKeysArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 10654  	if v, err := tp.ReadString(ctx); err != nil {
 10655  		return thrift.PrependError("error reading field 1: ", err)
 10656  	} else {
 10657  		p.Appid = v
 10658  	}
 10659  	return nil
 10660  }
 10661  
 10662  func (p *HKeysArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 10663  	if v, err := tp.ReadString(ctx); err != nil {
 10664  		return thrift.PrependError("error reading field 2: ", err)
 10665  	} else {
 10666  		p.Key = v
 10667  	}
 10668  	return nil
 10669  }
 10670  
 10671  func (p *HKeysArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 10672  	if err := tp.WriteStructBegin(ctx, "HKeys_args"); err != nil {
 10673  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10674  	}
 10675  	if p != nil {
 10676  		if err := p.writeField1(ctx, tp); err != nil {
 10677  			return err
 10678  		}
 10679  		if err := p.writeField2(ctx, tp); err != nil {
 10680  			return err
 10681  		}
 10682  	}
 10683  	if err := tp.WriteFieldStop(ctx); err != nil {
 10684  		return thrift.PrependError("write field stop error: ", err)
 10685  	}
 10686  	if err := tp.WriteStructEnd(ctx); err != nil {
 10687  		return thrift.PrependError("write struct stop error: ", err)
 10688  	}
 10689  	return nil
 10690  }
 10691  
 10692  func (p *HKeysArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 10693  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 10694  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 10695  	}
 10696  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 10697  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 10698  	}
 10699  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10700  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 10701  	}
 10702  	return err
 10703  }
 10704  
 10705  func (p *HKeysArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 10706  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 10707  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 10708  	}
 10709  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 10710  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 10711  	}
 10712  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10713  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 10714  	}
 10715  	return err
 10716  }
 10717  
 10718  func (p *HKeysArgs) String() string {
 10719  	if p == nil {
 10720  		return "<nil>"
 10721  	}
 10722  	return fmt.Sprintf("HKeysArgs(%+v)", *p)
 10723  }
 10724  
 10725  // Attributes:
 10726  //  - Success
 10727  type HKeysResult struct {
 10728  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 10729  }
 10730  
 10731  func NewHKeysResult() *HKeysResult {
 10732  	return &HKeysResult{}
 10733  }
 10734  
 10735  var HKeysResult_Success_DEFAULT *LResponse
 10736  
 10737  func (p *HKeysResult) GetSuccess() *LResponse {
 10738  	if !p.IsSetSuccess() {
 10739  		return HKeysResult_Success_DEFAULT
 10740  	}
 10741  	return p.Success
 10742  }
 10743  
 10744  func (p *HKeysResult) IsSetSuccess() bool {
 10745  	return p.Success != nil
 10746  }
 10747  
 10748  func (p *HKeysResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 10749  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10750  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10751  	}
 10752  
 10753  	for {
 10754  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10755  		if err != nil {
 10756  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10757  		}
 10758  		if fieldTypeId == thrift.STOP {
 10759  			break
 10760  		}
 10761  		switch fieldId {
 10762  		case 0:
 10763  			if fieldTypeId == thrift.STRUCT {
 10764  				if err := p.ReadField0(ctx, tp); err != nil {
 10765  					return err
 10766  				}
 10767  			} else {
 10768  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10769  					return err
 10770  				}
 10771  			}
 10772  		default:
 10773  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10774  				return err
 10775  			}
 10776  		}
 10777  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10778  			return err
 10779  		}
 10780  	}
 10781  	if err := tp.ReadStructEnd(ctx); err != nil {
 10782  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10783  	}
 10784  	return nil
 10785  }
 10786  
 10787  func (p *HKeysResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 10788  	p.Success = &LResponse{}
 10789  	if err := p.Success.Read(ctx, tp); err != nil {
 10790  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 10791  	}
 10792  	return nil
 10793  }
 10794  
 10795  func (p *HKeysResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 10796  	if err := tp.WriteStructBegin(ctx, "HKeys_result"); err != nil {
 10797  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10798  	}
 10799  	if p != nil {
 10800  		if err := p.writeField0(ctx, tp); err != nil {
 10801  			return err
 10802  		}
 10803  	}
 10804  	if err := tp.WriteFieldStop(ctx); err != nil {
 10805  		return thrift.PrependError("write field stop error: ", err)
 10806  	}
 10807  	if err := tp.WriteStructEnd(ctx); err != nil {
 10808  		return thrift.PrependError("write struct stop error: ", err)
 10809  	}
 10810  	return nil
 10811  }
 10812  
 10813  func (p *HKeysResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 10814  	if p.IsSetSuccess() {
 10815  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 10816  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 10817  		}
 10818  		if err := p.Success.Write(ctx, tp); err != nil {
 10819  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 10820  		}
 10821  		if err := tp.WriteFieldEnd(ctx); err != nil {
 10822  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 10823  		}
 10824  	}
 10825  	return err
 10826  }
 10827  
 10828  func (p *HKeysResult) String() string {
 10829  	if p == nil {
 10830  		return "<nil>"
 10831  	}
 10832  	return fmt.Sprintf("HKeysResult(%+v)", *p)
 10833  }
 10834  
 10835  // Attributes:
 10836  //  - Appid
 10837  //  - Key
 10838  type HValuesArgs struct {
 10839  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 10840  	Key   string `thrift:"key,2" db:"key" json:"key"`
 10841  }
 10842  
 10843  func NewHValuesArgs() *HValuesArgs {
 10844  	return &HValuesArgs{}
 10845  }
 10846  
 10847  func (p *HValuesArgs) GetAppid() string {
 10848  	return p.Appid
 10849  }
 10850  
 10851  func (p *HValuesArgs) GetKey() string {
 10852  	return p.Key
 10853  }
 10854  
 10855  func (p *HValuesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 10856  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 10857  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 10858  	}
 10859  
 10860  	for {
 10861  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 10862  		if err != nil {
 10863  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 10864  		}
 10865  		if fieldTypeId == thrift.STOP {
 10866  			break
 10867  		}
 10868  		switch fieldId {
 10869  		case 1:
 10870  			if fieldTypeId == thrift.STRING {
 10871  				if err := p.ReadField1(ctx, tp); err != nil {
 10872  					return err
 10873  				}
 10874  			} else {
 10875  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10876  					return err
 10877  				}
 10878  			}
 10879  		case 2:
 10880  			if fieldTypeId == thrift.STRING {
 10881  				if err := p.ReadField2(ctx, tp); err != nil {
 10882  					return err
 10883  				}
 10884  			} else {
 10885  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10886  					return err
 10887  				}
 10888  			}
 10889  		default:
 10890  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 10891  				return err
 10892  			}
 10893  		}
 10894  		if err := tp.ReadFieldEnd(ctx); err != nil {
 10895  			return err
 10896  		}
 10897  	}
 10898  	if err := tp.ReadStructEnd(ctx); err != nil {
 10899  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 10900  	}
 10901  	return nil
 10902  }
 10903  
 10904  func (p *HValuesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 10905  	if v, err := tp.ReadString(ctx); err != nil {
 10906  		return thrift.PrependError("error reading field 1: ", err)
 10907  	} else {
 10908  		p.Appid = v
 10909  	}
 10910  	return nil
 10911  }
 10912  
 10913  func (p *HValuesArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 10914  	if v, err := tp.ReadString(ctx); err != nil {
 10915  		return thrift.PrependError("error reading field 2: ", err)
 10916  	} else {
 10917  		p.Key = v
 10918  	}
 10919  	return nil
 10920  }
 10921  
 10922  func (p *HValuesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 10923  	if err := tp.WriteStructBegin(ctx, "HVals_args"); err != nil {
 10924  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 10925  	}
 10926  	if p != nil {
 10927  		if err := p.writeField1(ctx, tp); err != nil {
 10928  			return err
 10929  		}
 10930  		if err := p.writeField2(ctx, tp); err != nil {
 10931  			return err
 10932  		}
 10933  	}
 10934  	if err := tp.WriteFieldStop(ctx); err != nil {
 10935  		return thrift.PrependError("write field stop error: ", err)
 10936  	}
 10937  	if err := tp.WriteStructEnd(ctx); err != nil {
 10938  		return thrift.PrependError("write struct stop error: ", err)
 10939  	}
 10940  	return nil
 10941  }
 10942  
 10943  func (p *HValuesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 10944  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 10945  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 10946  	}
 10947  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 10948  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 10949  	}
 10950  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10951  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 10952  	}
 10953  	return err
 10954  }
 10955  
 10956  func (p *HValuesArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 10957  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 10958  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 10959  	}
 10960  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 10961  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 10962  	}
 10963  	if err := tp.WriteFieldEnd(ctx); err != nil {
 10964  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 10965  	}
 10966  	return err
 10967  }
 10968  
 10969  func (p *HValuesArgs) String() string {
 10970  	if p == nil {
 10971  		return "<nil>"
 10972  	}
 10973  	return fmt.Sprintf("HValuesArgs(%+v)", *p)
 10974  }
 10975  
 10976  // Attributes:
 10977  //  - Success
 10978  type HValuesResult struct {
 10979  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 10980  }
 10981  
 10982  func NewHValuesResult() *HValuesResult {
 10983  	return &HValuesResult{}
 10984  }
 10985  
 10986  var HValuesResult_Success_DEFAULT *LResponse
 10987  
 10988  func (p *HValuesResult) GetSuccess() *LResponse {
 10989  	if !p.IsSetSuccess() {
 10990  		return HValuesResult_Success_DEFAULT
 10991  	}
 10992  	return p.Success
 10993  }
 10994  
 10995  func (p *HValuesResult) IsSetSuccess() bool {
 10996  	return p.Success != nil
 10997  }
 10998  
 10999  func (p *HValuesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 11000  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11001  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11002  	}
 11003  
 11004  	for {
 11005  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11006  		if err != nil {
 11007  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11008  		}
 11009  		if fieldTypeId == thrift.STOP {
 11010  			break
 11011  		}
 11012  		switch fieldId {
 11013  		case 0:
 11014  			if fieldTypeId == thrift.STRUCT {
 11015  				if err := p.ReadField0(ctx, tp); err != nil {
 11016  					return err
 11017  				}
 11018  			} else {
 11019  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11020  					return err
 11021  				}
 11022  			}
 11023  		default:
 11024  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11025  				return err
 11026  			}
 11027  		}
 11028  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11029  			return err
 11030  		}
 11031  	}
 11032  	if err := tp.ReadStructEnd(ctx); err != nil {
 11033  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11034  	}
 11035  	return nil
 11036  }
 11037  
 11038  func (p *HValuesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 11039  	p.Success = &LResponse{}
 11040  	if err := p.Success.Read(ctx, tp); err != nil {
 11041  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 11042  	}
 11043  	return nil
 11044  }
 11045  
 11046  func (p *HValuesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 11047  	if err := tp.WriteStructBegin(ctx, "HVals_result"); err != nil {
 11048  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11049  	}
 11050  	if p != nil {
 11051  		if err := p.writeField0(ctx, tp); err != nil {
 11052  			return err
 11053  		}
 11054  	}
 11055  	if err := tp.WriteFieldStop(ctx); err != nil {
 11056  		return thrift.PrependError("write field stop error: ", err)
 11057  	}
 11058  	if err := tp.WriteStructEnd(ctx); err != nil {
 11059  		return thrift.PrependError("write struct stop error: ", err)
 11060  	}
 11061  	return nil
 11062  }
 11063  
 11064  func (p *HValuesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 11065  	if p.IsSetSuccess() {
 11066  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 11067  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 11068  		}
 11069  		if err := p.Success.Write(ctx, tp); err != nil {
 11070  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 11071  		}
 11072  		if err := tp.WriteFieldEnd(ctx); err != nil {
 11073  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 11074  		}
 11075  	}
 11076  	return err
 11077  }
 11078  
 11079  func (p *HValuesResult) String() string {
 11080  	if p == nil {
 11081  		return "<nil>"
 11082  	}
 11083  	return fmt.Sprintf("HValuesResult(%+v)", *p)
 11084  }
 11085  
 11086  // Attributes:
 11087  //  - Appid
 11088  //  - Key
 11089  //  - Field
 11090  //  - Inrc
 11091  type HIncrByArgs struct {
 11092  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 11093  	Key   string `thrift:"key,2" db:"key" json:"key"`
 11094  	Field string `thrift:"field,3" db:"field" json:"field"`
 11095  	Inrc  int64  `thrift:"inrc,4" db:"inrc" json:"inrc"`
 11096  }
 11097  
 11098  func NewHIncrByArgs() *HIncrByArgs {
 11099  	return &HIncrByArgs{}
 11100  }
 11101  
 11102  func (p *HIncrByArgs) GetAppid() string {
 11103  	return p.Appid
 11104  }
 11105  
 11106  func (p *HIncrByArgs) GetKey() string {
 11107  	return p.Key
 11108  }
 11109  
 11110  func (p *HIncrByArgs) GetField() string {
 11111  	return p.Field
 11112  }
 11113  
 11114  func (p *HIncrByArgs) GetInrc() int64 {
 11115  	return p.Inrc
 11116  }
 11117  
 11118  func (p *HIncrByArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 11119  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11120  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11121  	}
 11122  
 11123  	for {
 11124  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11125  		if err != nil {
 11126  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11127  		}
 11128  		if fieldTypeId == thrift.STOP {
 11129  			break
 11130  		}
 11131  		switch fieldId {
 11132  		case 1:
 11133  			if fieldTypeId == thrift.STRING {
 11134  				if err := p.ReadField1(ctx, tp); err != nil {
 11135  					return err
 11136  				}
 11137  			} else {
 11138  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11139  					return err
 11140  				}
 11141  			}
 11142  		case 2:
 11143  			if fieldTypeId == thrift.STRING {
 11144  				if err := p.ReadField2(ctx, tp); err != nil {
 11145  					return err
 11146  				}
 11147  			} else {
 11148  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11149  					return err
 11150  				}
 11151  			}
 11152  		case 3:
 11153  			if fieldTypeId == thrift.STRING {
 11154  				if err := p.ReadField3(ctx, tp); err != nil {
 11155  					return err
 11156  				}
 11157  			} else {
 11158  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11159  					return err
 11160  				}
 11161  			}
 11162  		case 4:
 11163  			if fieldTypeId == thrift.I64 {
 11164  				if err := p.ReadField4(ctx, tp); err != nil {
 11165  					return err
 11166  				}
 11167  			} else {
 11168  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11169  					return err
 11170  				}
 11171  			}
 11172  		default:
 11173  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11174  				return err
 11175  			}
 11176  		}
 11177  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11178  			return err
 11179  		}
 11180  	}
 11181  	if err := tp.ReadStructEnd(ctx); err != nil {
 11182  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11183  	}
 11184  	return nil
 11185  }
 11186  
 11187  func (p *HIncrByArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 11188  	if v, err := tp.ReadString(ctx); err != nil {
 11189  		return thrift.PrependError("error reading field 1: ", err)
 11190  	} else {
 11191  		p.Appid = v
 11192  	}
 11193  	return nil
 11194  }
 11195  
 11196  func (p *HIncrByArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 11197  	if v, err := tp.ReadString(ctx); err != nil {
 11198  		return thrift.PrependError("error reading field 2: ", err)
 11199  	} else {
 11200  		p.Key = v
 11201  	}
 11202  	return nil
 11203  }
 11204  
 11205  func (p *HIncrByArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 11206  	if v, err := tp.ReadString(ctx); err != nil {
 11207  		return thrift.PrependError("error reading field 3: ", err)
 11208  	} else {
 11209  		p.Field = v
 11210  	}
 11211  	return nil
 11212  }
 11213  
 11214  func (p *HIncrByArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 11215  	if v, err := tp.ReadI64(ctx); err != nil {
 11216  		return thrift.PrependError("error reading field 4: ", err)
 11217  	} else {
 11218  		p.Inrc = v
 11219  	}
 11220  	return nil
 11221  }
 11222  
 11223  func (p *HIncrByArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 11224  	if err := tp.WriteStructBegin(ctx, "HIncrBy_args"); err != nil {
 11225  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11226  	}
 11227  	if p != nil {
 11228  		if err := p.writeField1(ctx, tp); err != nil {
 11229  			return err
 11230  		}
 11231  		if err := p.writeField2(ctx, tp); err != nil {
 11232  			return err
 11233  		}
 11234  		if err := p.writeField3(ctx, tp); err != nil {
 11235  			return err
 11236  		}
 11237  		if err := p.writeField4(ctx, tp); err != nil {
 11238  			return err
 11239  		}
 11240  	}
 11241  	if err := tp.WriteFieldStop(ctx); err != nil {
 11242  		return thrift.PrependError("write field stop error: ", err)
 11243  	}
 11244  	if err := tp.WriteStructEnd(ctx); err != nil {
 11245  		return thrift.PrependError("write struct stop error: ", err)
 11246  	}
 11247  	return nil
 11248  }
 11249  
 11250  func (p *HIncrByArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 11251  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 11252  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 11253  	}
 11254  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 11255  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 11256  	}
 11257  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11258  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 11259  	}
 11260  	return err
 11261  }
 11262  
 11263  func (p *HIncrByArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 11264  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 11265  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 11266  	}
 11267  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 11268  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 11269  	}
 11270  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11271  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 11272  	}
 11273  	return err
 11274  }
 11275  
 11276  func (p *HIncrByArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 11277  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
 11278  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
 11279  	}
 11280  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
 11281  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
 11282  	}
 11283  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11284  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
 11285  	}
 11286  	return err
 11287  }
 11288  
 11289  func (p *HIncrByArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 11290  	if err := tp.WriteFieldBegin(ctx, "inrc", thrift.I64, 4); err != nil {
 11291  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:inrc: ", p), err)
 11292  	}
 11293  	if err := tp.WriteI64(ctx, int64(p.Inrc)); err != nil {
 11294  		return thrift.PrependError(fmt.Sprintf("%T.inrc (4) field write error: ", p), err)
 11295  	}
 11296  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11297  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:inrc: ", p), err)
 11298  	}
 11299  	return err
 11300  }
 11301  
 11302  func (p *HIncrByArgs) String() string {
 11303  	if p == nil {
 11304  		return "<nil>"
 11305  	}
 11306  	return fmt.Sprintf("HIncrByArgs(%+v)", *p)
 11307  }
 11308  
 11309  // Attributes:
 11310  //  - Success
 11311  type HIncrByResult struct {
 11312  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 11313  }
 11314  
 11315  func NewHIncrByResult() *HIncrByResult {
 11316  	return &HIncrByResult{}
 11317  }
 11318  
 11319  var HIncrByResult_Success_DEFAULT *IntResponse
 11320  
 11321  func (p *HIncrByResult) GetSuccess() *IntResponse {
 11322  	if !p.IsSetSuccess() {
 11323  		return HIncrByResult_Success_DEFAULT
 11324  	}
 11325  	return p.Success
 11326  }
 11327  func (p *HIncrByResult) IsSetSuccess() bool {
 11328  	return p.Success != nil
 11329  }
 11330  
 11331  func (p *HIncrByResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 11332  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11333  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11334  	}
 11335  
 11336  	for {
 11337  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11338  		if err != nil {
 11339  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11340  		}
 11341  		if fieldTypeId == thrift.STOP {
 11342  			break
 11343  		}
 11344  		switch fieldId {
 11345  		case 0:
 11346  			if fieldTypeId == thrift.STRUCT {
 11347  				if err := p.ReadField0(ctx, tp); err != nil {
 11348  					return err
 11349  				}
 11350  			} else {
 11351  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11352  					return err
 11353  				}
 11354  			}
 11355  		default:
 11356  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11357  				return err
 11358  			}
 11359  		}
 11360  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11361  			return err
 11362  		}
 11363  	}
 11364  	if err := tp.ReadStructEnd(ctx); err != nil {
 11365  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11366  	}
 11367  	return nil
 11368  }
 11369  
 11370  func (p *HIncrByResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 11371  	p.Success = &IntResponse{}
 11372  	if err := p.Success.Read(ctx, tp); err != nil {
 11373  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 11374  	}
 11375  	return nil
 11376  }
 11377  
 11378  func (p *HIncrByResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 11379  	if err := tp.WriteStructBegin(ctx, "HIncrBy_result"); err != nil {
 11380  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11381  	}
 11382  	if p != nil {
 11383  		if err := p.writeField0(ctx, tp); err != nil {
 11384  			return err
 11385  		}
 11386  	}
 11387  	if err := tp.WriteFieldStop(ctx); err != nil {
 11388  		return thrift.PrependError("write field stop error: ", err)
 11389  	}
 11390  	if err := tp.WriteStructEnd(ctx); err != nil {
 11391  		return thrift.PrependError("write struct stop error: ", err)
 11392  	}
 11393  	return nil
 11394  }
 11395  
 11396  func (p *HIncrByResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 11397  	if p.IsSetSuccess() {
 11398  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 11399  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 11400  		}
 11401  		if err := p.Success.Write(ctx, tp); err != nil {
 11402  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 11403  		}
 11404  		if err := tp.WriteFieldEnd(ctx); err != nil {
 11405  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 11406  		}
 11407  	}
 11408  	return err
 11409  }
 11410  
 11411  func (p *HIncrByResult) String() string {
 11412  	if p == nil {
 11413  		return "<nil>"
 11414  	}
 11415  	return fmt.Sprintf("HIncrByResult(%+v)", *p)
 11416  }
 11417  
 11418  // Attributes:
 11419  //  - Appid
 11420  //  - Key
 11421  //  - Field
 11422  //  - Inrc
 11423  type HIncrByFloatArgs struct {
 11424  	Appid string  `thrift:"appid,1" db:"appid" json:"appid"`
 11425  	Key   string  `thrift:"key,2" db:"key" json:"key"`
 11426  	Field string  `thrift:"field,3" db:"field" json:"field"`
 11427  	Inrc  float64 `thrift:"inrc,4" db:"inrc" json:"inrc"`
 11428  }
 11429  
 11430  func NewHIncrByFloatArgs() *HIncrByFloatArgs {
 11431  	return &HIncrByFloatArgs{}
 11432  }
 11433  
 11434  func (p *HIncrByFloatArgs) GetAppid() string {
 11435  	return p.Appid
 11436  }
 11437  
 11438  func (p *HIncrByFloatArgs) GetKey() string {
 11439  	return p.Key
 11440  }
 11441  
 11442  func (p *HIncrByFloatArgs) GetField() string {
 11443  	return p.Field
 11444  }
 11445  
 11446  func (p *HIncrByFloatArgs) GetInrc() float64 {
 11447  	return p.Inrc
 11448  }
 11449  
 11450  func (p *HIncrByFloatArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 11451  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11452  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11453  	}
 11454  
 11455  	for {
 11456  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11457  		if err != nil {
 11458  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11459  		}
 11460  		if fieldTypeId == thrift.STOP {
 11461  			break
 11462  		}
 11463  		switch fieldId {
 11464  		case 1:
 11465  			if fieldTypeId == thrift.STRING {
 11466  				if err := p.ReadField1(ctx, tp); err != nil {
 11467  					return err
 11468  				}
 11469  			} else {
 11470  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11471  					return err
 11472  				}
 11473  			}
 11474  		case 2:
 11475  			if fieldTypeId == thrift.STRING {
 11476  				if err := p.ReadField2(ctx, tp); err != nil {
 11477  					return err
 11478  				}
 11479  			} else {
 11480  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11481  					return err
 11482  				}
 11483  			}
 11484  		case 3:
 11485  			if fieldTypeId == thrift.STRING {
 11486  				if err := p.ReadField3(ctx, tp); err != nil {
 11487  					return err
 11488  				}
 11489  			} else {
 11490  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11491  					return err
 11492  				}
 11493  			}
 11494  		case 4:
 11495  			if fieldTypeId == thrift.DOUBLE {
 11496  				if err := p.ReadField4(ctx, tp); err != nil {
 11497  					return err
 11498  				}
 11499  			} else {
 11500  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11501  					return err
 11502  				}
 11503  			}
 11504  		default:
 11505  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11506  				return err
 11507  			}
 11508  		}
 11509  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11510  			return err
 11511  		}
 11512  	}
 11513  	if err := tp.ReadStructEnd(ctx); err != nil {
 11514  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11515  	}
 11516  	return nil
 11517  }
 11518  
 11519  func (p *HIncrByFloatArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 11520  	if v, err := tp.ReadString(ctx); err != nil {
 11521  		return thrift.PrependError("error reading field 1: ", err)
 11522  	} else {
 11523  		p.Appid = v
 11524  	}
 11525  	return nil
 11526  }
 11527  
 11528  func (p *HIncrByFloatArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 11529  	if v, err := tp.ReadString(ctx); err != nil {
 11530  		return thrift.PrependError("error reading field 2: ", err)
 11531  	} else {
 11532  		p.Key = v
 11533  	}
 11534  	return nil
 11535  }
 11536  
 11537  func (p *HIncrByFloatArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 11538  	if v, err := tp.ReadString(ctx); err != nil {
 11539  		return thrift.PrependError("error reading field 3: ", err)
 11540  	} else {
 11541  		p.Field = v
 11542  	}
 11543  	return nil
 11544  }
 11545  
 11546  func (p *HIncrByFloatArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 11547  	if v, err := tp.ReadDouble(ctx); err != nil {
 11548  		return thrift.PrependError("error reading field 4: ", err)
 11549  	} else {
 11550  		p.Inrc = v
 11551  	}
 11552  	return nil
 11553  }
 11554  
 11555  func (p *HIncrByFloatArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 11556  	if err := tp.WriteStructBegin(ctx, "HIncrByFloat_args"); err != nil {
 11557  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11558  	}
 11559  	if p != nil {
 11560  		if err := p.writeField1(ctx, tp); err != nil {
 11561  			return err
 11562  		}
 11563  		if err := p.writeField2(ctx, tp); err != nil {
 11564  			return err
 11565  		}
 11566  		if err := p.writeField3(ctx, tp); err != nil {
 11567  			return err
 11568  		}
 11569  		if err := p.writeField4(ctx, tp); err != nil {
 11570  			return err
 11571  		}
 11572  	}
 11573  	if err := tp.WriteFieldStop(ctx); err != nil {
 11574  		return thrift.PrependError("write field stop error: ", err)
 11575  	}
 11576  	if err := tp.WriteStructEnd(ctx); err != nil {
 11577  		return thrift.PrependError("write struct stop error: ", err)
 11578  	}
 11579  	return nil
 11580  }
 11581  
 11582  func (p *HIncrByFloatArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 11583  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 11584  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 11585  	}
 11586  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 11587  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 11588  	}
 11589  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11590  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 11591  	}
 11592  	return err
 11593  }
 11594  
 11595  func (p *HIncrByFloatArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 11596  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 11597  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 11598  	}
 11599  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 11600  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 11601  	}
 11602  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11603  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 11604  	}
 11605  	return err
 11606  }
 11607  
 11608  func (p *HIncrByFloatArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 11609  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
 11610  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
 11611  	}
 11612  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
 11613  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
 11614  	}
 11615  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11616  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
 11617  	}
 11618  	return err
 11619  }
 11620  
 11621  func (p *HIncrByFloatArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 11622  	if err := tp.WriteFieldBegin(ctx, "inrc", thrift.DOUBLE, 4); err != nil {
 11623  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:inrc: ", p), err)
 11624  	}
 11625  	if err := tp.WriteDouble(ctx, float64(p.Inrc)); err != nil {
 11626  		return thrift.PrependError(fmt.Sprintf("%T.inrc (4) field write error: ", p), err)
 11627  	}
 11628  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11629  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:inrc: ", p), err)
 11630  	}
 11631  	return err
 11632  }
 11633  
 11634  func (p *HIncrByFloatArgs) String() string {
 11635  	if p == nil {
 11636  		return "<nil>"
 11637  	}
 11638  	return fmt.Sprintf("HIncrByFloatArgs(%+v)", *p)
 11639  }
 11640  
 11641  // Attributes:
 11642  //  - Success
 11643  type HIncrByFloatResult struct {
 11644  	Success *FloatResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 11645  }
 11646  
 11647  func NewHIncrByFloatResult() *HIncrByFloatResult {
 11648  	return &HIncrByFloatResult{}
 11649  }
 11650  
 11651  var HIncrByFloatResult_Success_DEFAULT *FloatResponse
 11652  
 11653  func (p *HIncrByFloatResult) GetSuccess() *FloatResponse {
 11654  	if !p.IsSetSuccess() {
 11655  		return HIncrByFloatResult_Success_DEFAULT
 11656  	}
 11657  	return p.Success
 11658  }
 11659  
 11660  func (p *HIncrByFloatResult) IsSetSuccess() bool {
 11661  	return p.Success != nil
 11662  }
 11663  
 11664  func (p *HIncrByFloatResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 11665  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11666  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11667  	}
 11668  
 11669  	for {
 11670  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11671  		if err != nil {
 11672  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11673  		}
 11674  		if fieldTypeId == thrift.STOP {
 11675  			break
 11676  		}
 11677  		switch fieldId {
 11678  		case 0:
 11679  			if fieldTypeId == thrift.STRUCT {
 11680  				if err := p.ReadField0(ctx, tp); err != nil {
 11681  					return err
 11682  				}
 11683  			} else {
 11684  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11685  					return err
 11686  				}
 11687  			}
 11688  		default:
 11689  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11690  				return err
 11691  			}
 11692  		}
 11693  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11694  			return err
 11695  		}
 11696  	}
 11697  	if err := tp.ReadStructEnd(ctx); err != nil {
 11698  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11699  	}
 11700  	return nil
 11701  }
 11702  
 11703  func (p *HIncrByFloatResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 11704  	p.Success = &FloatResponse{}
 11705  	if err := p.Success.Read(ctx, tp); err != nil {
 11706  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 11707  	}
 11708  	return nil
 11709  }
 11710  
 11711  func (p *HIncrByFloatResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 11712  	if err := tp.WriteStructBegin(ctx, "HIncrByFloat_result"); err != nil {
 11713  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11714  	}
 11715  	if p != nil {
 11716  		if err := p.writeField0(ctx, tp); err != nil {
 11717  			return err
 11718  		}
 11719  	}
 11720  	if err := tp.WriteFieldStop(ctx); err != nil {
 11721  		return thrift.PrependError("write field stop error: ", err)
 11722  	}
 11723  	if err := tp.WriteStructEnd(ctx); err != nil {
 11724  		return thrift.PrependError("write struct stop error: ", err)
 11725  	}
 11726  	return nil
 11727  }
 11728  
 11729  func (p *HIncrByFloatResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 11730  	if p.IsSetSuccess() {
 11731  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 11732  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 11733  		}
 11734  		if err := p.Success.Write(ctx, tp); err != nil {
 11735  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 11736  		}
 11737  		if err := tp.WriteFieldEnd(ctx); err != nil {
 11738  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 11739  		}
 11740  	}
 11741  	return err
 11742  }
 11743  
 11744  func (p *HIncrByFloatResult) String() string {
 11745  	if p == nil {
 11746  		return "<nil>"
 11747  	}
 11748  	return fmt.Sprintf("HIncrByFloatResult(%+v)", *p)
 11749  }
 11750  
 11751  // Attributes:
 11752  //  - Appid
 11753  //  - Key
 11754  //  - Field
 11755  type HExistsArgs struct {
 11756  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 11757  	Key   string `thrift:"key,2" db:"key" json:"key"`
 11758  	Field string `thrift:"field,3" db:"field" json:"field"`
 11759  }
 11760  
 11761  func NewHExistsArgs() *HExistsArgs {
 11762  	return &HExistsArgs{}
 11763  }
 11764  
 11765  func (p *HExistsArgs) GetAppid() string {
 11766  	return p.Appid
 11767  }
 11768  
 11769  func (p *HExistsArgs) GetKey() string {
 11770  	return p.Key
 11771  }
 11772  
 11773  func (p *HExistsArgs) GetField() string {
 11774  	return p.Field
 11775  }
 11776  func (p *HExistsArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 11777  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11778  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11779  	}
 11780  
 11781  	for {
 11782  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11783  		if err != nil {
 11784  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11785  		}
 11786  		if fieldTypeId == thrift.STOP {
 11787  			break
 11788  		}
 11789  		switch fieldId {
 11790  		case 1:
 11791  			if fieldTypeId == thrift.STRING {
 11792  				if err := p.ReadField1(ctx, tp); err != nil {
 11793  					return err
 11794  				}
 11795  			} else {
 11796  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11797  					return err
 11798  				}
 11799  			}
 11800  		case 2:
 11801  			if fieldTypeId == thrift.STRING {
 11802  				if err := p.ReadField2(ctx, tp); err != nil {
 11803  					return err
 11804  				}
 11805  			} else {
 11806  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11807  					return err
 11808  				}
 11809  			}
 11810  		case 3:
 11811  			if fieldTypeId == thrift.STRING {
 11812  				if err := p.ReadField3(ctx, tp); err != nil {
 11813  					return err
 11814  				}
 11815  			} else {
 11816  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11817  					return err
 11818  				}
 11819  			}
 11820  		default:
 11821  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11822  				return err
 11823  			}
 11824  		}
 11825  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11826  			return err
 11827  		}
 11828  	}
 11829  	if err := tp.ReadStructEnd(ctx); err != nil {
 11830  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11831  	}
 11832  	return nil
 11833  }
 11834  
 11835  func (p *HExistsArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 11836  	if v, err := tp.ReadString(ctx); err != nil {
 11837  		return thrift.PrependError("error reading field 1: ", err)
 11838  	} else {
 11839  		p.Appid = v
 11840  	}
 11841  	return nil
 11842  }
 11843  
 11844  func (p *HExistsArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 11845  	if v, err := tp.ReadString(ctx); err != nil {
 11846  		return thrift.PrependError("error reading field 2: ", err)
 11847  	} else {
 11848  		p.Key = v
 11849  	}
 11850  	return nil
 11851  }
 11852  
 11853  func (p *HExistsArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 11854  	if v, err := tp.ReadString(ctx); err != nil {
 11855  		return thrift.PrependError("error reading field 3: ", err)
 11856  	} else {
 11857  		p.Field = v
 11858  	}
 11859  	return nil
 11860  }
 11861  
 11862  func (p *HExistsArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 11863  	if err := tp.WriteStructBegin(ctx, "HExists_args"); err != nil {
 11864  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 11865  	}
 11866  	if p != nil {
 11867  		if err := p.writeField1(ctx, tp); err != nil {
 11868  			return err
 11869  		}
 11870  		if err := p.writeField2(ctx, tp); err != nil {
 11871  			return err
 11872  		}
 11873  		if err := p.writeField3(ctx, tp); err != nil {
 11874  			return err
 11875  		}
 11876  	}
 11877  	if err := tp.WriteFieldStop(ctx); err != nil {
 11878  		return thrift.PrependError("write field stop error: ", err)
 11879  	}
 11880  	if err := tp.WriteStructEnd(ctx); err != nil {
 11881  		return thrift.PrependError("write struct stop error: ", err)
 11882  	}
 11883  	return nil
 11884  }
 11885  
 11886  func (p *HExistsArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 11887  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 11888  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 11889  	}
 11890  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 11891  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 11892  	}
 11893  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11894  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 11895  	}
 11896  	return err
 11897  }
 11898  
 11899  func (p *HExistsArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 11900  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 11901  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 11902  	}
 11903  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 11904  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 11905  	}
 11906  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11907  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 11908  	}
 11909  	return err
 11910  }
 11911  
 11912  func (p *HExistsArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 11913  	if err := tp.WriteFieldBegin(ctx, "field", thrift.STRING, 3); err != nil {
 11914  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:field: ", p), err)
 11915  	}
 11916  	if err := tp.WriteString(ctx, string(p.Field)); err != nil {
 11917  		return thrift.PrependError(fmt.Sprintf("%T.field (3) field write error: ", p), err)
 11918  	}
 11919  	if err := tp.WriteFieldEnd(ctx); err != nil {
 11920  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:field: ", p), err)
 11921  	}
 11922  	return err
 11923  }
 11924  
 11925  func (p *HExistsArgs) String() string {
 11926  	if p == nil {
 11927  		return "<nil>"
 11928  	}
 11929  	return fmt.Sprintf("HExistsArgs(%+v)", *p)
 11930  }
 11931  
 11932  // Attributes:
 11933  //  - Success
 11934  type HExistsResult struct {
 11935  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 11936  }
 11937  
 11938  func NewHExistsResult() *HExistsResult {
 11939  	return &HExistsResult{}
 11940  }
 11941  
 11942  var HExistsResult_Success_DEFAULT *Response
 11943  
 11944  func (p *HExistsResult) GetSuccess() *Response {
 11945  	if !p.IsSetSuccess() {
 11946  		return HExistsResult_Success_DEFAULT
 11947  	}
 11948  	return p.Success
 11949  }
 11950  
 11951  func (p *HExistsResult) IsSetSuccess() bool {
 11952  	return p.Success != nil
 11953  }
 11954  
 11955  func (p *HExistsResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 11956  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 11957  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 11958  	}
 11959  
 11960  	for {
 11961  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 11962  		if err != nil {
 11963  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 11964  		}
 11965  		if fieldTypeId == thrift.STOP {
 11966  			break
 11967  		}
 11968  		switch fieldId {
 11969  		case 0:
 11970  			if fieldTypeId == thrift.STRUCT {
 11971  				if err := p.ReadField0(ctx, tp); err != nil {
 11972  					return err
 11973  				}
 11974  			} else {
 11975  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11976  					return err
 11977  				}
 11978  			}
 11979  		default:
 11980  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 11981  				return err
 11982  			}
 11983  		}
 11984  		if err := tp.ReadFieldEnd(ctx); err != nil {
 11985  			return err
 11986  		}
 11987  	}
 11988  	if err := tp.ReadStructEnd(ctx); err != nil {
 11989  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 11990  	}
 11991  	return nil
 11992  }
 11993  
 11994  func (p *HExistsResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 11995  	p.Success = &Response{}
 11996  	if err := p.Success.Read(ctx, tp); err != nil {
 11997  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 11998  	}
 11999  	return nil
 12000  }
 12001  
 12002  func (p *HExistsResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 12003  	if err := tp.WriteStructBegin(ctx, "HExists_result"); err != nil {
 12004  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12005  	}
 12006  	if p != nil {
 12007  		if err := p.writeField0(ctx, tp); err != nil {
 12008  			return err
 12009  		}
 12010  	}
 12011  	if err := tp.WriteFieldStop(ctx); err != nil {
 12012  		return thrift.PrependError("write field stop error: ", err)
 12013  	}
 12014  	if err := tp.WriteStructEnd(ctx); err != nil {
 12015  		return thrift.PrependError("write struct stop error: ", err)
 12016  	}
 12017  	return nil
 12018  }
 12019  
 12020  func (p *HExistsResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 12021  	if p.IsSetSuccess() {
 12022  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 12023  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 12024  		}
 12025  		if err := p.Success.Write(ctx, tp); err != nil {
 12026  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 12027  		}
 12028  		if err := tp.WriteFieldEnd(ctx); err != nil {
 12029  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 12030  		}
 12031  	}
 12032  	return err
 12033  }
 12034  
 12035  func (p *HExistsResult) String() string {
 12036  	if p == nil {
 12037  		return "<nil>"
 12038  	}
 12039  	return fmt.Sprintf("HExistsResult(%+v)", *p)
 12040  }
 12041  
 12042  // Attributes:
 12043  //  - Appid
 12044  //  - Key
 12045  //  - Member
 12046  type ZAddArgs struct {
 12047  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 12048  	Key    string `thrift:"key,2" db:"key" json:"key"`
 12049  	Member *Z     `thrift:"member,3" db:"member" json:"member"`
 12050  }
 12051  
 12052  func NewRedisProxyZAddArgs() *ZAddArgs {
 12053  	return &ZAddArgs{}
 12054  }
 12055  
 12056  func (p *ZAddArgs) GetAppid() string {
 12057  	return p.Appid
 12058  }
 12059  
 12060  func (p *ZAddArgs) GetKey() string {
 12061  	return p.Key
 12062  }
 12063  
 12064  var ZAddArgs_Member_DEFAULT *Z
 12065  
 12066  func (p *ZAddArgs) GetMember() *Z {
 12067  	if !p.IsSetMember() {
 12068  		return ZAddArgs_Member_DEFAULT
 12069  	}
 12070  	return p.Member
 12071  }
 12072  
 12073  func (p *ZAddArgs) IsSetMember() bool {
 12074  	return p.Member != nil
 12075  }
 12076  
 12077  func (p *ZAddArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 12078  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12079  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12080  	}
 12081  
 12082  	for {
 12083  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12084  		if err != nil {
 12085  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12086  		}
 12087  		if fieldTypeId == thrift.STOP {
 12088  			break
 12089  		}
 12090  		switch fieldId {
 12091  		case 1:
 12092  			if fieldTypeId == thrift.STRING {
 12093  				if err := p.ReadField1(ctx, tp); err != nil {
 12094  					return err
 12095  				}
 12096  			} else {
 12097  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12098  					return err
 12099  				}
 12100  			}
 12101  		case 2:
 12102  			if fieldTypeId == thrift.STRING {
 12103  				if err := p.ReadField2(ctx, tp); err != nil {
 12104  					return err
 12105  				}
 12106  			} else {
 12107  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12108  					return err
 12109  				}
 12110  			}
 12111  		case 3:
 12112  			if fieldTypeId == thrift.STRUCT {
 12113  				if err := p.ReadField3(ctx, tp); err != nil {
 12114  					return err
 12115  				}
 12116  			} else {
 12117  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12118  					return err
 12119  				}
 12120  			}
 12121  		default:
 12122  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12123  				return err
 12124  			}
 12125  		}
 12126  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12127  			return err
 12128  		}
 12129  	}
 12130  	if err := tp.ReadStructEnd(ctx); err != nil {
 12131  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12132  	}
 12133  	return nil
 12134  }
 12135  
 12136  func (p *ZAddArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 12137  	if v, err := tp.ReadString(ctx); err != nil {
 12138  		return thrift.PrependError("error reading field 1: ", err)
 12139  	} else {
 12140  		p.Appid = v
 12141  	}
 12142  	return nil
 12143  }
 12144  
 12145  func (p *ZAddArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 12146  	if v, err := tp.ReadString(ctx); err != nil {
 12147  		return thrift.PrependError("error reading field 2: ", err)
 12148  	} else {
 12149  		p.Key = v
 12150  	}
 12151  	return nil
 12152  }
 12153  
 12154  func (p *ZAddArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 12155  	p.Member = &Z{}
 12156  	if err := p.Member.Read(ctx, tp); err != nil {
 12157  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Member), err)
 12158  	}
 12159  	return nil
 12160  }
 12161  
 12162  func (p *ZAddArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 12163  	if err := tp.WriteStructBegin(ctx, "ZAdd_args"); err != nil {
 12164  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12165  	}
 12166  	if p != nil {
 12167  		if err := p.writeField1(ctx, tp); err != nil {
 12168  			return err
 12169  		}
 12170  		if err := p.writeField2(ctx, tp); err != nil {
 12171  			return err
 12172  		}
 12173  		if err := p.writeField3(ctx, tp); err != nil {
 12174  			return err
 12175  		}
 12176  	}
 12177  	if err := tp.WriteFieldStop(ctx); err != nil {
 12178  		return thrift.PrependError("write field stop error: ", err)
 12179  	}
 12180  	if err := tp.WriteStructEnd(ctx); err != nil {
 12181  		return thrift.PrependError("write struct stop error: ", err)
 12182  	}
 12183  	return nil
 12184  }
 12185  
 12186  func (p *ZAddArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 12187  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 12188  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 12189  	}
 12190  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 12191  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 12192  	}
 12193  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12194  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 12195  	}
 12196  	return err
 12197  }
 12198  
 12199  func (p *ZAddArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 12200  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 12201  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 12202  	}
 12203  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 12204  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 12205  	}
 12206  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12207  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 12208  	}
 12209  	return err
 12210  }
 12211  
 12212  func (p *ZAddArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 12213  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRUCT, 3); err != nil {
 12214  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 12215  	}
 12216  	if err := p.Member.Write(ctx, tp); err != nil {
 12217  		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Member), err)
 12218  	}
 12219  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12220  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 12221  	}
 12222  	return err
 12223  }
 12224  
 12225  func (p *ZAddArgs) String() string {
 12226  	if p == nil {
 12227  		return "<nil>"
 12228  	}
 12229  	return fmt.Sprintf("ZAddArgs(%+v)", *p)
 12230  }
 12231  
 12232  // Attributes:
 12233  //  - Success
 12234  type ZAddResult struct {
 12235  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 12236  }
 12237  
 12238  func NewZAddResult() *ZAddResult {
 12239  	return &ZAddResult{}
 12240  }
 12241  
 12242  var ZAddResult_Success_DEFAULT *IntResponse
 12243  
 12244  func (p *ZAddResult) GetSuccess() *IntResponse {
 12245  	if !p.IsSetSuccess() {
 12246  		return ZAddResult_Success_DEFAULT
 12247  	}
 12248  	return p.Success
 12249  }
 12250  
 12251  func (p *ZAddResult) IsSetSuccess() bool {
 12252  	return p.Success != nil
 12253  }
 12254  
 12255  func (p *ZAddResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 12256  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12257  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12258  	}
 12259  
 12260  	for {
 12261  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12262  		if err != nil {
 12263  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12264  		}
 12265  		if fieldTypeId == thrift.STOP {
 12266  			break
 12267  		}
 12268  		switch fieldId {
 12269  		case 0:
 12270  			if fieldTypeId == thrift.STRUCT {
 12271  				if err := p.ReadField0(ctx, tp); err != nil {
 12272  					return err
 12273  				}
 12274  			} else {
 12275  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12276  					return err
 12277  				}
 12278  			}
 12279  		default:
 12280  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12281  				return err
 12282  			}
 12283  		}
 12284  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12285  			return err
 12286  		}
 12287  	}
 12288  	if err := tp.ReadStructEnd(ctx); err != nil {
 12289  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12290  	}
 12291  	return nil
 12292  }
 12293  
 12294  func (p *ZAddResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 12295  	p.Success = &IntResponse{}
 12296  	if err := p.Success.Read(ctx, tp); err != nil {
 12297  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 12298  	}
 12299  	return nil
 12300  }
 12301  
 12302  func (p *ZAddResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 12303  	if err := tp.WriteStructBegin(ctx, "ZAdd_result"); err != nil {
 12304  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12305  	}
 12306  	if p != nil {
 12307  		if err := p.writeField0(ctx, tp); err != nil {
 12308  			return err
 12309  		}
 12310  	}
 12311  	if err := tp.WriteFieldStop(ctx); err != nil {
 12312  		return thrift.PrependError("write field stop error: ", err)
 12313  	}
 12314  	if err := tp.WriteStructEnd(ctx); err != nil {
 12315  		return thrift.PrependError("write struct stop error: ", err)
 12316  	}
 12317  	return nil
 12318  }
 12319  
 12320  func (p *ZAddResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 12321  	if p.IsSetSuccess() {
 12322  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 12323  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 12324  		}
 12325  		if err := p.Success.Write(ctx, tp); err != nil {
 12326  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 12327  		}
 12328  		if err := tp.WriteFieldEnd(ctx); err != nil {
 12329  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 12330  		}
 12331  	}
 12332  	return err
 12333  }
 12334  
 12335  func (p *ZAddResult) String() string {
 12336  	if p == nil {
 12337  		return "<nil>"
 12338  	}
 12339  	return fmt.Sprintf("ZAddResult(%+v)", *p)
 12340  }
 12341  
 12342  // Attributes:
 12343  //  - Appid
 12344  //  - Key
 12345  //  - Members
 12346  type MzAddArgs struct {
 12347  	Appid   string `thrift:"appid,1" db:"appid" json:"appid"`
 12348  	Key     string `thrift:"key,2" db:"key" json:"key"`
 12349  	Members []*Z   `thrift:"members,3" db:"members" json:"members"`
 12350  }
 12351  
 12352  func NewMZAddArgs() *MzAddArgs {
 12353  	return &MzAddArgs{}
 12354  }
 12355  
 12356  func (p *MzAddArgs) GetAppid() string {
 12357  	return p.Appid
 12358  }
 12359  
 12360  func (p *MzAddArgs) GetKey() string {
 12361  	return p.Key
 12362  }
 12363  
 12364  func (p *MzAddArgs) GetMembers() []*Z {
 12365  	return p.Members
 12366  }
 12367  
 12368  func (p *MzAddArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 12369  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12370  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12371  	}
 12372  
 12373  	for {
 12374  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12375  		if err != nil {
 12376  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12377  		}
 12378  		if fieldTypeId == thrift.STOP {
 12379  			break
 12380  		}
 12381  		switch fieldId {
 12382  		case 1:
 12383  			if fieldTypeId == thrift.STRING {
 12384  				if err := p.ReadField1(ctx, tp); err != nil {
 12385  					return err
 12386  				}
 12387  			} else {
 12388  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12389  					return err
 12390  				}
 12391  			}
 12392  		case 2:
 12393  			if fieldTypeId == thrift.STRING {
 12394  				if err := p.ReadField2(ctx, tp); err != nil {
 12395  					return err
 12396  				}
 12397  			} else {
 12398  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12399  					return err
 12400  				}
 12401  			}
 12402  		case 3:
 12403  			if fieldTypeId == thrift.LIST {
 12404  				if err := p.ReadField3(ctx, tp); err != nil {
 12405  					return err
 12406  				}
 12407  			} else {
 12408  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12409  					return err
 12410  				}
 12411  			}
 12412  		default:
 12413  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12414  				return err
 12415  			}
 12416  		}
 12417  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12418  			return err
 12419  		}
 12420  	}
 12421  	if err := tp.ReadStructEnd(ctx); err != nil {
 12422  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12423  	}
 12424  	return nil
 12425  }
 12426  
 12427  func (p *MzAddArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 12428  	if v, err := tp.ReadString(ctx); err != nil {
 12429  		return thrift.PrependError("error reading field 1: ", err)
 12430  	} else {
 12431  		p.Appid = v
 12432  	}
 12433  	return nil
 12434  }
 12435  
 12436  func (p *MzAddArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 12437  	if v, err := tp.ReadString(ctx); err != nil {
 12438  		return thrift.PrependError("error reading field 2: ", err)
 12439  	} else {
 12440  		p.Key = v
 12441  	}
 12442  	return nil
 12443  }
 12444  
 12445  func (p *MzAddArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 12446  	_, size, err := tp.ReadListBegin(ctx)
 12447  	if err != nil {
 12448  		return thrift.PrependError("error reading list begin: ", err)
 12449  	}
 12450  	tSlice := make([]*Z, 0, size)
 12451  	p.Members = tSlice
 12452  	for i := 0; i < size; i++ {
 12453  		_elem193 := &Z{}
 12454  		if err := _elem193.Read(ctx, tp); err != nil {
 12455  			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem193), err)
 12456  		}
 12457  		p.Members = append(p.Members, _elem193)
 12458  	}
 12459  	if err := tp.ReadListEnd(ctx); err != nil {
 12460  		return thrift.PrependError("error reading list end: ", err)
 12461  	}
 12462  	return nil
 12463  }
 12464  
 12465  func (p *MzAddArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 12466  	if err := tp.WriteStructBegin(ctx, "MZAdd_args"); err != nil {
 12467  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12468  	}
 12469  	if p != nil {
 12470  		if err := p.writeField1(ctx, tp); err != nil {
 12471  			return err
 12472  		}
 12473  		if err := p.writeField2(ctx, tp); err != nil {
 12474  			return err
 12475  		}
 12476  		if err := p.writeField3(ctx, tp); err != nil {
 12477  			return err
 12478  		}
 12479  	}
 12480  	if err := tp.WriteFieldStop(ctx); err != nil {
 12481  		return thrift.PrependError("write field stop error: ", err)
 12482  	}
 12483  	if err := tp.WriteStructEnd(ctx); err != nil {
 12484  		return thrift.PrependError("write struct stop error: ", err)
 12485  	}
 12486  	return nil
 12487  }
 12488  
 12489  func (p *MzAddArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 12490  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 12491  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 12492  	}
 12493  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 12494  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 12495  	}
 12496  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12497  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 12498  	}
 12499  	return err
 12500  }
 12501  
 12502  func (p *MzAddArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 12503  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 12504  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 12505  	}
 12506  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 12507  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 12508  	}
 12509  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12510  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 12511  	}
 12512  	return err
 12513  }
 12514  
 12515  func (p *MzAddArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 12516  	if err := tp.WriteFieldBegin(ctx, "members", thrift.LIST, 3); err != nil {
 12517  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:members: ", p), err)
 12518  	}
 12519  	if err := tp.WriteListBegin(ctx, thrift.STRUCT, len(p.Members)); err != nil {
 12520  		return thrift.PrependError("error writing list begin: ", err)
 12521  	}
 12522  	for _, v := range p.Members {
 12523  		if err := v.Write(ctx, tp); err != nil {
 12524  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
 12525  		}
 12526  	}
 12527  	if err := tp.WriteListEnd(ctx); err != nil {
 12528  		return thrift.PrependError("error writing list end: ", err)
 12529  	}
 12530  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12531  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:members: ", p), err)
 12532  	}
 12533  	return err
 12534  }
 12535  
 12536  func (p *MzAddArgs) String() string {
 12537  	if p == nil {
 12538  		return "<nil>"
 12539  	}
 12540  	return fmt.Sprintf("MzAddArgs(%+v)", *p)
 12541  }
 12542  
 12543  // Attributes:
 12544  //  - Success
 12545  type MzAddResult struct {
 12546  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 12547  }
 12548  
 12549  func NewMZAddResult() *MzAddResult {
 12550  	return &MzAddResult{}
 12551  }
 12552  
 12553  var MZAddResult_Success_DEFAULT *IntResponse
 12554  
 12555  func (p *MzAddResult) GetSuccess() *IntResponse {
 12556  	if !p.IsSetSuccess() {
 12557  		return MZAddResult_Success_DEFAULT
 12558  	}
 12559  	return p.Success
 12560  }
 12561  func (p *MzAddResult) IsSetSuccess() bool {
 12562  	return p.Success != nil
 12563  }
 12564  
 12565  func (p *MzAddResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 12566  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12567  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12568  	}
 12569  
 12570  	for {
 12571  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12572  		if err != nil {
 12573  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12574  		}
 12575  		if fieldTypeId == thrift.STOP {
 12576  			break
 12577  		}
 12578  		switch fieldId {
 12579  		case 0:
 12580  			if fieldTypeId == thrift.STRUCT {
 12581  				if err := p.ReadField0(ctx, tp); err != nil {
 12582  					return err
 12583  				}
 12584  			} else {
 12585  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12586  					return err
 12587  				}
 12588  			}
 12589  		default:
 12590  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12591  				return err
 12592  			}
 12593  		}
 12594  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12595  			return err
 12596  		}
 12597  	}
 12598  	if err := tp.ReadStructEnd(ctx); err != nil {
 12599  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12600  	}
 12601  	return nil
 12602  }
 12603  
 12604  func (p *MzAddResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 12605  	p.Success = &IntResponse{}
 12606  	if err := p.Success.Read(ctx, tp); err != nil {
 12607  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 12608  	}
 12609  	return nil
 12610  }
 12611  
 12612  func (p *MzAddResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 12613  	if err := tp.WriteStructBegin(ctx, "MZAdd_result"); err != nil {
 12614  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12615  	}
 12616  	if p != nil {
 12617  		if err := p.writeField0(ctx, tp); err != nil {
 12618  			return err
 12619  		}
 12620  	}
 12621  	if err := tp.WriteFieldStop(ctx); err != nil {
 12622  		return thrift.PrependError("write field stop error: ", err)
 12623  	}
 12624  	if err := tp.WriteStructEnd(ctx); err != nil {
 12625  		return thrift.PrependError("write struct stop error: ", err)
 12626  	}
 12627  	return nil
 12628  }
 12629  
 12630  func (p *MzAddResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 12631  	if p.IsSetSuccess() {
 12632  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 12633  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 12634  		}
 12635  		if err := p.Success.Write(ctx, tp); err != nil {
 12636  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 12637  		}
 12638  		if err := tp.WriteFieldEnd(ctx); err != nil {
 12639  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 12640  		}
 12641  	}
 12642  	return err
 12643  }
 12644  
 12645  func (p *MzAddResult) String() string {
 12646  	if p == nil {
 12647  		return "<nil>"
 12648  	}
 12649  	return fmt.Sprintf("MzAddResult(%+v)", *p)
 12650  }
 12651  
 12652  // Attributes:
 12653  //  - Appid
 12654  //  - Key
 12655  type ZCardArgs struct {
 12656  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 12657  	Key   string `thrift:"key,2" db:"key" json:"key"`
 12658  }
 12659  
 12660  func NewZCardArgs() *ZCardArgs {
 12661  	return &ZCardArgs{}
 12662  }
 12663  
 12664  func (p *ZCardArgs) GetAppid() string {
 12665  	return p.Appid
 12666  }
 12667  
 12668  func (p *ZCardArgs) GetKey() string {
 12669  	return p.Key
 12670  }
 12671  func (p *ZCardArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 12672  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12673  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12674  	}
 12675  
 12676  	for {
 12677  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12678  		if err != nil {
 12679  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12680  		}
 12681  		if fieldTypeId == thrift.STOP {
 12682  			break
 12683  		}
 12684  		switch fieldId {
 12685  		case 1:
 12686  			if fieldTypeId == thrift.STRING {
 12687  				if err := p.ReadField1(ctx, tp); err != nil {
 12688  					return err
 12689  				}
 12690  			} else {
 12691  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12692  					return err
 12693  				}
 12694  			}
 12695  		case 2:
 12696  			if fieldTypeId == thrift.STRING {
 12697  				if err := p.ReadField2(ctx, tp); err != nil {
 12698  					return err
 12699  				}
 12700  			} else {
 12701  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12702  					return err
 12703  				}
 12704  			}
 12705  		default:
 12706  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12707  				return err
 12708  			}
 12709  		}
 12710  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12711  			return err
 12712  		}
 12713  	}
 12714  	if err := tp.ReadStructEnd(ctx); err != nil {
 12715  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12716  	}
 12717  	return nil
 12718  }
 12719  
 12720  func (p *ZCardArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 12721  	if v, err := tp.ReadString(ctx); err != nil {
 12722  		return thrift.PrependError("error reading field 1: ", err)
 12723  	} else {
 12724  		p.Appid = v
 12725  	}
 12726  	return nil
 12727  }
 12728  
 12729  func (p *ZCardArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 12730  	if v, err := tp.ReadString(ctx); err != nil {
 12731  		return thrift.PrependError("error reading field 2: ", err)
 12732  	} else {
 12733  		p.Key = v
 12734  	}
 12735  	return nil
 12736  }
 12737  
 12738  func (p *ZCardArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 12739  	if err := tp.WriteStructBegin(ctx, "ZCard_args"); err != nil {
 12740  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12741  	}
 12742  	if p != nil {
 12743  		if err := p.writeField1(ctx, tp); err != nil {
 12744  			return err
 12745  		}
 12746  		if err := p.writeField2(ctx, tp); err != nil {
 12747  			return err
 12748  		}
 12749  	}
 12750  	if err := tp.WriteFieldStop(ctx); err != nil {
 12751  		return thrift.PrependError("write field stop error: ", err)
 12752  	}
 12753  	if err := tp.WriteStructEnd(ctx); err != nil {
 12754  		return thrift.PrependError("write struct stop error: ", err)
 12755  	}
 12756  	return nil
 12757  }
 12758  
 12759  func (p *ZCardArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 12760  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 12761  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 12762  	}
 12763  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 12764  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 12765  	}
 12766  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12767  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 12768  	}
 12769  	return err
 12770  }
 12771  
 12772  func (p *ZCardArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 12773  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 12774  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 12775  	}
 12776  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 12777  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 12778  	}
 12779  	if err := tp.WriteFieldEnd(ctx); err != nil {
 12780  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 12781  	}
 12782  	return err
 12783  }
 12784  
 12785  func (p *ZCardArgs) String() string {
 12786  	if p == nil {
 12787  		return "<nil>"
 12788  	}
 12789  	return fmt.Sprintf("ZCardArgs(%+v)", *p)
 12790  }
 12791  
 12792  // Attributes:
 12793  //  - Success
 12794  type ZCardResult struct {
 12795  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 12796  }
 12797  
 12798  func NewZCardResult() *ZCardResult {
 12799  	return &ZCardResult{}
 12800  }
 12801  
 12802  var ZCardResult_Success_DEFAULT *IntResponse
 12803  
 12804  func (p *ZCardResult) GetSuccess() *IntResponse {
 12805  	if !p.IsSetSuccess() {
 12806  		return ZCardResult_Success_DEFAULT
 12807  	}
 12808  	return p.Success
 12809  }
 12810  func (p *ZCardResult) IsSetSuccess() bool {
 12811  	return p.Success != nil
 12812  }
 12813  
 12814  func (p *ZCardResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 12815  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12816  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12817  	}
 12818  
 12819  	for {
 12820  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12821  		if err != nil {
 12822  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12823  		}
 12824  		if fieldTypeId == thrift.STOP {
 12825  			break
 12826  		}
 12827  		switch fieldId {
 12828  		case 0:
 12829  			if fieldTypeId == thrift.STRUCT {
 12830  				if err := p.ReadField0(ctx, tp); err != nil {
 12831  					return err
 12832  				}
 12833  			} else {
 12834  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12835  					return err
 12836  				}
 12837  			}
 12838  		default:
 12839  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12840  				return err
 12841  			}
 12842  		}
 12843  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12844  			return err
 12845  		}
 12846  	}
 12847  	if err := tp.ReadStructEnd(ctx); err != nil {
 12848  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12849  	}
 12850  	return nil
 12851  }
 12852  
 12853  func (p *ZCardResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 12854  	p.Success = &IntResponse{}
 12855  	if err := p.Success.Read(ctx, tp); err != nil {
 12856  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 12857  	}
 12858  	return nil
 12859  }
 12860  
 12861  func (p *ZCardResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 12862  	if err := tp.WriteStructBegin(ctx, "ZCard_result"); err != nil {
 12863  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 12864  	}
 12865  	if p != nil {
 12866  		if err := p.writeField0(ctx, tp); err != nil {
 12867  			return err
 12868  		}
 12869  	}
 12870  	if err := tp.WriteFieldStop(ctx); err != nil {
 12871  		return thrift.PrependError("write field stop error: ", err)
 12872  	}
 12873  	if err := tp.WriteStructEnd(ctx); err != nil {
 12874  		return thrift.PrependError("write struct stop error: ", err)
 12875  	}
 12876  	return nil
 12877  }
 12878  
 12879  func (p *ZCardResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 12880  	if p.IsSetSuccess() {
 12881  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 12882  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 12883  		}
 12884  		if err := p.Success.Write(ctx, tp); err != nil {
 12885  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 12886  		}
 12887  		if err := tp.WriteFieldEnd(ctx); err != nil {
 12888  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 12889  		}
 12890  	}
 12891  	return err
 12892  }
 12893  
 12894  func (p *ZCardResult) String() string {
 12895  	if p == nil {
 12896  		return "<nil>"
 12897  	}
 12898  	return fmt.Sprintf("ZCardResult(%+v)", *p)
 12899  }
 12900  
 12901  // Attributes:
 12902  //  - Appid
 12903  //  - Key
 12904  //  - Min
 12905  //  - Max
 12906  type ZCountArgs struct {
 12907  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 12908  	Key   string `thrift:"key,2" db:"key" json:"key"`
 12909  	Min   string `thrift:"min,3" db:"min" json:"min"`
 12910  	Max   string `thrift:"max,4" db:"max" json:"max"`
 12911  }
 12912  
 12913  func NewZCountArgs() *ZCountArgs {
 12914  	return &ZCountArgs{}
 12915  }
 12916  
 12917  func (p *ZCountArgs) GetAppid() string {
 12918  	return p.Appid
 12919  }
 12920  
 12921  func (p *ZCountArgs) GetKey() string {
 12922  	return p.Key
 12923  }
 12924  
 12925  func (p *ZCountArgs) GetMin() string {
 12926  	return p.Min
 12927  }
 12928  
 12929  func (p *ZCountArgs) GetMax() string {
 12930  	return p.Max
 12931  }
 12932  
 12933  func (p *ZCountArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 12934  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 12935  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 12936  	}
 12937  
 12938  	for {
 12939  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 12940  		if err != nil {
 12941  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 12942  		}
 12943  		if fieldTypeId == thrift.STOP {
 12944  			break
 12945  		}
 12946  		switch fieldId {
 12947  		case 1:
 12948  			if fieldTypeId == thrift.STRING {
 12949  				if err := p.ReadField1(ctx, tp); err != nil {
 12950  					return err
 12951  				}
 12952  			} else {
 12953  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12954  					return err
 12955  				}
 12956  			}
 12957  		case 2:
 12958  			if fieldTypeId == thrift.STRING {
 12959  				if err := p.ReadField2(ctx, tp); err != nil {
 12960  					return err
 12961  				}
 12962  			} else {
 12963  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12964  					return err
 12965  				}
 12966  			}
 12967  		case 3:
 12968  			if fieldTypeId == thrift.STRING {
 12969  				if err := p.ReadField3(ctx, tp); err != nil {
 12970  					return err
 12971  				}
 12972  			} else {
 12973  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12974  					return err
 12975  				}
 12976  			}
 12977  		case 4:
 12978  			if fieldTypeId == thrift.STRING {
 12979  				if err := p.ReadField4(ctx, tp); err != nil {
 12980  					return err
 12981  				}
 12982  			} else {
 12983  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12984  					return err
 12985  				}
 12986  			}
 12987  		default:
 12988  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 12989  				return err
 12990  			}
 12991  		}
 12992  		if err := tp.ReadFieldEnd(ctx); err != nil {
 12993  			return err
 12994  		}
 12995  	}
 12996  	if err := tp.ReadStructEnd(ctx); err != nil {
 12997  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 12998  	}
 12999  	return nil
 13000  }
 13001  
 13002  func (p *ZCountArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 13003  	if v, err := tp.ReadString(ctx); err != nil {
 13004  		return thrift.PrependError("error reading field 1: ", err)
 13005  	} else {
 13006  		p.Appid = v
 13007  	}
 13008  	return nil
 13009  }
 13010  
 13011  func (p *ZCountArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 13012  	if v, err := tp.ReadString(ctx); err != nil {
 13013  		return thrift.PrependError("error reading field 2: ", err)
 13014  	} else {
 13015  		p.Key = v
 13016  	}
 13017  	return nil
 13018  }
 13019  
 13020  func (p *ZCountArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 13021  	if v, err := tp.ReadString(ctx); err != nil {
 13022  		return thrift.PrependError("error reading field 3: ", err)
 13023  	} else {
 13024  		p.Min = v
 13025  	}
 13026  	return nil
 13027  }
 13028  
 13029  func (p *ZCountArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 13030  	if v, err := tp.ReadString(ctx); err != nil {
 13031  		return thrift.PrependError("error reading field 4: ", err)
 13032  	} else {
 13033  		p.Max = v
 13034  	}
 13035  	return nil
 13036  }
 13037  
 13038  func (p *ZCountArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 13039  	if err := tp.WriteStructBegin(ctx, "ZCount_args"); err != nil {
 13040  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13041  	}
 13042  	if p != nil {
 13043  		if err := p.writeField1(ctx, tp); err != nil {
 13044  			return err
 13045  		}
 13046  		if err := p.writeField2(ctx, tp); err != nil {
 13047  			return err
 13048  		}
 13049  		if err := p.writeField3(ctx, tp); err != nil {
 13050  			return err
 13051  		}
 13052  		if err := p.writeField4(ctx, tp); err != nil {
 13053  			return err
 13054  		}
 13055  	}
 13056  	if err := tp.WriteFieldStop(ctx); err != nil {
 13057  		return thrift.PrependError("write field stop error: ", err)
 13058  	}
 13059  	if err := tp.WriteStructEnd(ctx); err != nil {
 13060  		return thrift.PrependError("write struct stop error: ", err)
 13061  	}
 13062  	return nil
 13063  }
 13064  
 13065  func (p *ZCountArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 13066  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 13067  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 13068  	}
 13069  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 13070  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 13071  	}
 13072  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13073  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 13074  	}
 13075  	return err
 13076  }
 13077  
 13078  func (p *ZCountArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 13079  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 13080  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 13081  	}
 13082  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 13083  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 13084  	}
 13085  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13086  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 13087  	}
 13088  	return err
 13089  }
 13090  
 13091  func (p *ZCountArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 13092  	if err := tp.WriteFieldBegin(ctx, "min", thrift.STRING, 3); err != nil {
 13093  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:min: ", p), err)
 13094  	}
 13095  	if err := tp.WriteString(ctx, string(p.Min)); err != nil {
 13096  		return thrift.PrependError(fmt.Sprintf("%T.min (3) field write error: ", p), err)
 13097  	}
 13098  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13099  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:min: ", p), err)
 13100  	}
 13101  	return err
 13102  }
 13103  
 13104  func (p *ZCountArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 13105  	if err := tp.WriteFieldBegin(ctx, "max", thrift.STRING, 4); err != nil {
 13106  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:max: ", p), err)
 13107  	}
 13108  	if err := tp.WriteString(ctx, string(p.Max)); err != nil {
 13109  		return thrift.PrependError(fmt.Sprintf("%T.max (4) field write error: ", p), err)
 13110  	}
 13111  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13112  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:max: ", p), err)
 13113  	}
 13114  	return err
 13115  }
 13116  
 13117  func (p *ZCountArgs) String() string {
 13118  	if p == nil {
 13119  		return "<nil>"
 13120  	}
 13121  	return fmt.Sprintf("ZCountArgs(%+v)", *p)
 13122  }
 13123  
 13124  // Attributes:
 13125  //  - Success
 13126  type ZCountResult struct {
 13127  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 13128  }
 13129  
 13130  func NewZCountResult() *ZCountResult {
 13131  	return &ZCountResult{}
 13132  }
 13133  
 13134  var ZCountResult_Success_DEFAULT *IntResponse
 13135  
 13136  func (p *ZCountResult) GetSuccess() *IntResponse {
 13137  	if !p.IsSetSuccess() {
 13138  		return ZCountResult_Success_DEFAULT
 13139  	}
 13140  	return p.Success
 13141  }
 13142  func (p *ZCountResult) IsSetSuccess() bool {
 13143  	return p.Success != nil
 13144  }
 13145  
 13146  func (p *ZCountResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 13147  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 13148  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 13149  	}
 13150  
 13151  	for {
 13152  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 13153  		if err != nil {
 13154  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 13155  		}
 13156  		if fieldTypeId == thrift.STOP {
 13157  			break
 13158  		}
 13159  		switch fieldId {
 13160  		case 0:
 13161  			if fieldTypeId == thrift.STRUCT {
 13162  				if err := p.ReadField0(ctx, tp); err != nil {
 13163  					return err
 13164  				}
 13165  			} else {
 13166  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13167  					return err
 13168  				}
 13169  			}
 13170  		default:
 13171  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13172  				return err
 13173  			}
 13174  		}
 13175  		if err := tp.ReadFieldEnd(ctx); err != nil {
 13176  			return err
 13177  		}
 13178  	}
 13179  	if err := tp.ReadStructEnd(ctx); err != nil {
 13180  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 13181  	}
 13182  	return nil
 13183  }
 13184  
 13185  func (p *ZCountResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 13186  	p.Success = &IntResponse{}
 13187  	if err := p.Success.Read(ctx, tp); err != nil {
 13188  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 13189  	}
 13190  	return nil
 13191  }
 13192  
 13193  func (p *ZCountResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 13194  	if err := tp.WriteStructBegin(ctx, "ZCount_result"); err != nil {
 13195  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13196  	}
 13197  	if p != nil {
 13198  		if err := p.writeField0(ctx, tp); err != nil {
 13199  			return err
 13200  		}
 13201  	}
 13202  	if err := tp.WriteFieldStop(ctx); err != nil {
 13203  		return thrift.PrependError("write field stop error: ", err)
 13204  	}
 13205  	if err := tp.WriteStructEnd(ctx); err != nil {
 13206  		return thrift.PrependError("write struct stop error: ", err)
 13207  	}
 13208  	return nil
 13209  }
 13210  
 13211  func (p *ZCountResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 13212  	if p.IsSetSuccess() {
 13213  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 13214  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 13215  		}
 13216  		if err := p.Success.Write(ctx, tp); err != nil {
 13217  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 13218  		}
 13219  		if err := tp.WriteFieldEnd(ctx); err != nil {
 13220  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 13221  		}
 13222  	}
 13223  	return err
 13224  }
 13225  
 13226  func (p *ZCountResult) String() string {
 13227  	if p == nil {
 13228  		return "<nil>"
 13229  	}
 13230  	return fmt.Sprintf("ZCountResult(%+v)", *p)
 13231  }
 13232  
 13233  // Attributes:
 13234  //  - Appid
 13235  //  - Key
 13236  //  - Start
 13237  //  - Stop
 13238  type ZRangeWithScoresArgs struct {
 13239  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 13240  	Key   string `thrift:"key,2" db:"key" json:"key"`
 13241  	Start int64  `thrift:"start,3" db:"start" json:"start"`
 13242  	Stop  int64  `thrift:"stop,4" db:"stop" json:"stop"`
 13243  }
 13244  
 13245  func NewZRangeWithScoresArgs() *ZRangeWithScoresArgs {
 13246  	return &ZRangeWithScoresArgs{}
 13247  }
 13248  
 13249  func (p *ZRangeWithScoresArgs) GetAppid() string {
 13250  	return p.Appid
 13251  }
 13252  
 13253  func (p *ZRangeWithScoresArgs) GetKey() string {
 13254  	return p.Key
 13255  }
 13256  
 13257  func (p *ZRangeWithScoresArgs) GetStart() int64 {
 13258  	return p.Start
 13259  }
 13260  
 13261  func (p *ZRangeWithScoresArgs) GetStop() int64 {
 13262  	return p.Stop
 13263  }
 13264  
 13265  func (p *ZRangeWithScoresArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 13266  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 13267  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 13268  	}
 13269  
 13270  	for {
 13271  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 13272  		if err != nil {
 13273  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 13274  		}
 13275  		if fieldTypeId == thrift.STOP {
 13276  			break
 13277  		}
 13278  		switch fieldId {
 13279  		case 1:
 13280  			if fieldTypeId == thrift.STRING {
 13281  				if err := p.ReadField1(ctx, tp); err != nil {
 13282  					return err
 13283  				}
 13284  			} else {
 13285  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13286  					return err
 13287  				}
 13288  			}
 13289  		case 2:
 13290  			if fieldTypeId == thrift.STRING {
 13291  				if err := p.ReadField2(ctx, tp); err != nil {
 13292  					return err
 13293  				}
 13294  			} else {
 13295  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13296  					return err
 13297  				}
 13298  			}
 13299  		case 3:
 13300  			if fieldTypeId == thrift.I64 {
 13301  				if err := p.ReadField3(ctx, tp); err != nil {
 13302  					return err
 13303  				}
 13304  			} else {
 13305  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13306  					return err
 13307  				}
 13308  			}
 13309  		case 4:
 13310  			if fieldTypeId == thrift.I64 {
 13311  				if err := p.ReadField4(ctx, tp); err != nil {
 13312  					return err
 13313  				}
 13314  			} else {
 13315  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13316  					return err
 13317  				}
 13318  			}
 13319  		default:
 13320  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13321  				return err
 13322  			}
 13323  		}
 13324  		if err := tp.ReadFieldEnd(ctx); err != nil {
 13325  			return err
 13326  		}
 13327  	}
 13328  	if err := tp.ReadStructEnd(ctx); err != nil {
 13329  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 13330  	}
 13331  	return nil
 13332  }
 13333  
 13334  func (p *ZRangeWithScoresArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 13335  	if v, err := tp.ReadString(ctx); err != nil {
 13336  		return thrift.PrependError("error reading field 1: ", err)
 13337  	} else {
 13338  		p.Appid = v
 13339  	}
 13340  	return nil
 13341  }
 13342  
 13343  func (p *ZRangeWithScoresArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 13344  	if v, err := tp.ReadString(ctx); err != nil {
 13345  		return thrift.PrependError("error reading field 2: ", err)
 13346  	} else {
 13347  		p.Key = v
 13348  	}
 13349  	return nil
 13350  }
 13351  
 13352  func (p *ZRangeWithScoresArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 13353  	if v, err := tp.ReadI64(ctx); err != nil {
 13354  		return thrift.PrependError("error reading field 3: ", err)
 13355  	} else {
 13356  		p.Start = v
 13357  	}
 13358  	return nil
 13359  }
 13360  
 13361  func (p *ZRangeWithScoresArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 13362  	if v, err := tp.ReadI64(ctx); err != nil {
 13363  		return thrift.PrependError("error reading field 4: ", err)
 13364  	} else {
 13365  		p.Stop = v
 13366  	}
 13367  	return nil
 13368  }
 13369  
 13370  func (p *ZRangeWithScoresArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 13371  	if err := tp.WriteStructBegin(ctx, "ZRangeWithScores_args"); err != nil {
 13372  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13373  	}
 13374  	if p != nil {
 13375  		if err := p.writeField1(ctx, tp); err != nil {
 13376  			return err
 13377  		}
 13378  		if err := p.writeField2(ctx, tp); err != nil {
 13379  			return err
 13380  		}
 13381  		if err := p.writeField3(ctx, tp); err != nil {
 13382  			return err
 13383  		}
 13384  		if err := p.writeField4(ctx, tp); err != nil {
 13385  			return err
 13386  		}
 13387  	}
 13388  	if err := tp.WriteFieldStop(ctx); err != nil {
 13389  		return thrift.PrependError("write field stop error: ", err)
 13390  	}
 13391  	if err := tp.WriteStructEnd(ctx); err != nil {
 13392  		return thrift.PrependError("write struct stop error: ", err)
 13393  	}
 13394  	return nil
 13395  }
 13396  
 13397  func (p *ZRangeWithScoresArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 13398  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 13399  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 13400  	}
 13401  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 13402  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 13403  	}
 13404  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13405  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 13406  	}
 13407  	return err
 13408  }
 13409  
 13410  func (p *ZRangeWithScoresArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 13411  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 13412  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 13413  	}
 13414  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 13415  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 13416  	}
 13417  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13418  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 13419  	}
 13420  	return err
 13421  }
 13422  
 13423  func (p *ZRangeWithScoresArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 13424  	if err := tp.WriteFieldBegin(ctx, "start", thrift.I64, 3); err != nil {
 13425  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:start: ", p), err)
 13426  	}
 13427  	if err := tp.WriteI64(ctx, int64(p.Start)); err != nil {
 13428  		return thrift.PrependError(fmt.Sprintf("%T.start (3) field write error: ", p), err)
 13429  	}
 13430  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13431  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:start: ", p), err)
 13432  	}
 13433  	return err
 13434  }
 13435  
 13436  func (p *ZRangeWithScoresArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 13437  	if err := tp.WriteFieldBegin(ctx, "stop", thrift.I64, 4); err != nil {
 13438  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:stop: ", p), err)
 13439  	}
 13440  	if err := tp.WriteI64(ctx, int64(p.Stop)); err != nil {
 13441  		return thrift.PrependError(fmt.Sprintf("%T.stop (4) field write error: ", p), err)
 13442  	}
 13443  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13444  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:stop: ", p), err)
 13445  	}
 13446  	return err
 13447  }
 13448  
 13449  func (p *ZRangeWithScoresArgs) String() string {
 13450  	if p == nil {
 13451  		return "<nil>"
 13452  	}
 13453  	return fmt.Sprintf("ZRangeWithScoresArgs(%+v)", *p)
 13454  }
 13455  
 13456  // Attributes:
 13457  //  - Success
 13458  type ZRangeWithScoresResult struct {
 13459  	Success *ZResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 13460  }
 13461  
 13462  func NewZRangeWithScoresResult() *ZRangeWithScoresResult {
 13463  	return &ZRangeWithScoresResult{}
 13464  }
 13465  
 13466  var ZRangeWithScoresResult_Success_DEFAULT *ZResponse
 13467  
 13468  func (p *ZRangeWithScoresResult) GetSuccess() *ZResponse {
 13469  	if !p.IsSetSuccess() {
 13470  		return ZRangeWithScoresResult_Success_DEFAULT
 13471  	}
 13472  	return p.Success
 13473  }
 13474  func (p *ZRangeWithScoresResult) IsSetSuccess() bool {
 13475  	return p.Success != nil
 13476  }
 13477  
 13478  func (p *ZRangeWithScoresResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 13479  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 13480  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 13481  	}
 13482  
 13483  	for {
 13484  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 13485  		if err != nil {
 13486  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 13487  		}
 13488  		if fieldTypeId == thrift.STOP {
 13489  			break
 13490  		}
 13491  		switch fieldId {
 13492  		case 0:
 13493  			if fieldTypeId == thrift.STRUCT {
 13494  				if err := p.ReadField0(ctx, tp); err != nil {
 13495  					return err
 13496  				}
 13497  			} else {
 13498  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13499  					return err
 13500  				}
 13501  			}
 13502  		default:
 13503  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13504  				return err
 13505  			}
 13506  		}
 13507  		if err := tp.ReadFieldEnd(ctx); err != nil {
 13508  			return err
 13509  		}
 13510  	}
 13511  	if err := tp.ReadStructEnd(ctx); err != nil {
 13512  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 13513  	}
 13514  	return nil
 13515  }
 13516  
 13517  func (p *ZRangeWithScoresResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 13518  	p.Success = &ZResponse{}
 13519  	if err := p.Success.Read(ctx, tp); err != nil {
 13520  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 13521  	}
 13522  	return nil
 13523  }
 13524  
 13525  func (p *ZRangeWithScoresResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 13526  	if err := tp.WriteStructBegin(ctx, "ZRangeWithScores_result"); err != nil {
 13527  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13528  	}
 13529  	if p != nil {
 13530  		if err := p.writeField0(ctx, tp); err != nil {
 13531  			return err
 13532  		}
 13533  	}
 13534  	if err := tp.WriteFieldStop(ctx); err != nil {
 13535  		return thrift.PrependError("write field stop error: ", err)
 13536  	}
 13537  	if err := tp.WriteStructEnd(ctx); err != nil {
 13538  		return thrift.PrependError("write struct stop error: ", err)
 13539  	}
 13540  	return nil
 13541  }
 13542  
 13543  func (p *ZRangeWithScoresResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 13544  	if p.IsSetSuccess() {
 13545  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 13546  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 13547  		}
 13548  		if err := p.Success.Write(ctx, tp); err != nil {
 13549  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 13550  		}
 13551  		if err := tp.WriteFieldEnd(ctx); err != nil {
 13552  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 13553  		}
 13554  	}
 13555  	return err
 13556  }
 13557  
 13558  func (p *ZRangeWithScoresResult) String() string {
 13559  	if p == nil {
 13560  		return "<nil>"
 13561  	}
 13562  	return fmt.Sprintf("ZRangeWithScoresResult(%+v)", *p)
 13563  }
 13564  
 13565  // Attributes:
 13566  //  - Appid
 13567  //  - Key
 13568  //  - Min
 13569  //  - Max
 13570  //  - Offset
 13571  //  - Count
 13572  type ZRangeByScoreWithScoresArgs struct {
 13573  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 13574  	Key    string `thrift:"key,2" db:"key" json:"key"`
 13575  	Min    string `thrift:"min,3" db:"min" json:"min"`
 13576  	Max    string `thrift:"max,4" db:"max" json:"max"`
 13577  	Offset int64  `thrift:"offset,5" db:"offset" json:"offset"`
 13578  	Count  int64  `thrift:"count,6" db:"count" json:"count"`
 13579  }
 13580  
 13581  func NewZRangeByScoreWithScoresArgs() *ZRangeByScoreWithScoresArgs {
 13582  	return &ZRangeByScoreWithScoresArgs{}
 13583  }
 13584  
 13585  func (p *ZRangeByScoreWithScoresArgs) GetAppid() string {
 13586  	return p.Appid
 13587  }
 13588  
 13589  func (p *ZRangeByScoreWithScoresArgs) GetKey() string {
 13590  	return p.Key
 13591  }
 13592  
 13593  func (p *ZRangeByScoreWithScoresArgs) GetMin() string {
 13594  	return p.Min
 13595  }
 13596  
 13597  func (p *ZRangeByScoreWithScoresArgs) GetMax() string {
 13598  	return p.Max
 13599  }
 13600  
 13601  func (p *ZRangeByScoreWithScoresArgs) GetOffset() int64 {
 13602  	return p.Offset
 13603  }
 13604  
 13605  func (p *ZRangeByScoreWithScoresArgs) GetCount() int64 {
 13606  	return p.Count
 13607  }
 13608  func (p *ZRangeByScoreWithScoresArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 13609  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 13610  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 13611  	}
 13612  
 13613  	for {
 13614  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 13615  		if err != nil {
 13616  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 13617  		}
 13618  		if fieldTypeId == thrift.STOP {
 13619  			break
 13620  		}
 13621  		switch fieldId {
 13622  		case 1:
 13623  			if fieldTypeId == thrift.STRING {
 13624  				if err := p.ReadField1(ctx, tp); err != nil {
 13625  					return err
 13626  				}
 13627  			} else {
 13628  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13629  					return err
 13630  				}
 13631  			}
 13632  		case 2:
 13633  			if fieldTypeId == thrift.STRING {
 13634  				if err := p.ReadField2(ctx, tp); err != nil {
 13635  					return err
 13636  				}
 13637  			} else {
 13638  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13639  					return err
 13640  				}
 13641  			}
 13642  		case 3:
 13643  			if fieldTypeId == thrift.STRING {
 13644  				if err := p.ReadField3(ctx, tp); err != nil {
 13645  					return err
 13646  				}
 13647  			} else {
 13648  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13649  					return err
 13650  				}
 13651  			}
 13652  		case 4:
 13653  			if fieldTypeId == thrift.STRING {
 13654  				if err := p.ReadField4(ctx, tp); err != nil {
 13655  					return err
 13656  				}
 13657  			} else {
 13658  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13659  					return err
 13660  				}
 13661  			}
 13662  		case 5:
 13663  			if fieldTypeId == thrift.I64 {
 13664  				if err := p.ReadField5(ctx, tp); err != nil {
 13665  					return err
 13666  				}
 13667  			} else {
 13668  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13669  					return err
 13670  				}
 13671  			}
 13672  		case 6:
 13673  			if fieldTypeId == thrift.I64 {
 13674  				if err := p.ReadField6(ctx, tp); err != nil {
 13675  					return err
 13676  				}
 13677  			} else {
 13678  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13679  					return err
 13680  				}
 13681  			}
 13682  		default:
 13683  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13684  				return err
 13685  			}
 13686  		}
 13687  		if err := tp.ReadFieldEnd(ctx); err != nil {
 13688  			return err
 13689  		}
 13690  	}
 13691  	if err := tp.ReadStructEnd(ctx); err != nil {
 13692  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 13693  	}
 13694  	return nil
 13695  }
 13696  
 13697  func (p *ZRangeByScoreWithScoresArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 13698  	if v, err := tp.ReadString(ctx); err != nil {
 13699  		return thrift.PrependError("error reading field 1: ", err)
 13700  	} else {
 13701  		p.Appid = v
 13702  	}
 13703  	return nil
 13704  }
 13705  
 13706  func (p *ZRangeByScoreWithScoresArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 13707  	if v, err := tp.ReadString(ctx); err != nil {
 13708  		return thrift.PrependError("error reading field 2: ", err)
 13709  	} else {
 13710  		p.Key = v
 13711  	}
 13712  	return nil
 13713  }
 13714  
 13715  func (p *ZRangeByScoreWithScoresArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 13716  	if v, err := tp.ReadString(ctx); err != nil {
 13717  		return thrift.PrependError("error reading field 3: ", err)
 13718  	} else {
 13719  		p.Min = v
 13720  	}
 13721  	return nil
 13722  }
 13723  
 13724  func (p *ZRangeByScoreWithScoresArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 13725  	if v, err := tp.ReadString(ctx); err != nil {
 13726  		return thrift.PrependError("error reading field 4: ", err)
 13727  	} else {
 13728  		p.Max = v
 13729  	}
 13730  	return nil
 13731  }
 13732  
 13733  func (p *ZRangeByScoreWithScoresArgs) ReadField5(ctx context.Context, tp thrift.TProtocol) error {
 13734  	if v, err := tp.ReadI64(ctx); err != nil {
 13735  		return thrift.PrependError("error reading field 5: ", err)
 13736  	} else {
 13737  		p.Offset = v
 13738  	}
 13739  	return nil
 13740  }
 13741  
 13742  func (p *ZRangeByScoreWithScoresArgs) ReadField6(ctx context.Context, tp thrift.TProtocol) error {
 13743  	if v, err := tp.ReadI64(ctx); err != nil {
 13744  		return thrift.PrependError("error reading field 6: ", err)
 13745  	} else {
 13746  		p.Count = v
 13747  	}
 13748  	return nil
 13749  }
 13750  
 13751  func (p *ZRangeByScoreWithScoresArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 13752  	if err := tp.WriteStructBegin(ctx, "ZRangeByScoreWithScores_args"); err != nil {
 13753  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13754  	}
 13755  	if p != nil {
 13756  		if err := p.writeField1(ctx, tp); err != nil {
 13757  			return err
 13758  		}
 13759  		if err := p.writeField2(ctx, tp); err != nil {
 13760  			return err
 13761  		}
 13762  		if err := p.writeField3(ctx, tp); err != nil {
 13763  			return err
 13764  		}
 13765  		if err := p.writeField4(ctx, tp); err != nil {
 13766  			return err
 13767  		}
 13768  		if err := p.writeField5(ctx, tp); err != nil {
 13769  			return err
 13770  		}
 13771  		if err := p.writeField6(ctx, tp); err != nil {
 13772  			return err
 13773  		}
 13774  	}
 13775  	if err := tp.WriteFieldStop(ctx); err != nil {
 13776  		return thrift.PrependError("write field stop error: ", err)
 13777  	}
 13778  	if err := tp.WriteStructEnd(ctx); err != nil {
 13779  		return thrift.PrependError("write struct stop error: ", err)
 13780  	}
 13781  	return nil
 13782  }
 13783  
 13784  func (p *ZRangeByScoreWithScoresArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 13785  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 13786  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 13787  	}
 13788  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 13789  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 13790  	}
 13791  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13792  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 13793  	}
 13794  	return err
 13795  }
 13796  
 13797  func (p *ZRangeByScoreWithScoresArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 13798  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 13799  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 13800  	}
 13801  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 13802  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 13803  	}
 13804  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13805  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 13806  	}
 13807  	return err
 13808  }
 13809  
 13810  func (p *ZRangeByScoreWithScoresArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 13811  	if err := tp.WriteFieldBegin(ctx, "min", thrift.STRING, 3); err != nil {
 13812  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:min: ", p), err)
 13813  	}
 13814  	if err := tp.WriteString(ctx, string(p.Min)); err != nil {
 13815  		return thrift.PrependError(fmt.Sprintf("%T.min (3) field write error: ", p), err)
 13816  	}
 13817  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13818  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:min: ", p), err)
 13819  	}
 13820  	return err
 13821  }
 13822  
 13823  func (p *ZRangeByScoreWithScoresArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 13824  	if err := tp.WriteFieldBegin(ctx, "max", thrift.STRING, 4); err != nil {
 13825  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:max: ", p), err)
 13826  	}
 13827  	if err := tp.WriteString(ctx, string(p.Max)); err != nil {
 13828  		return thrift.PrependError(fmt.Sprintf("%T.max (4) field write error: ", p), err)
 13829  	}
 13830  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13831  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:max: ", p), err)
 13832  	}
 13833  	return err
 13834  }
 13835  
 13836  func (p *ZRangeByScoreWithScoresArgs) writeField5(ctx context.Context, tp thrift.TProtocol) (err error) {
 13837  	if err := tp.WriteFieldBegin(ctx, "offset", thrift.I64, 5); err != nil {
 13838  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:offset: ", p), err)
 13839  	}
 13840  	if err := tp.WriteI64(ctx, int64(p.Offset)); err != nil {
 13841  		return thrift.PrependError(fmt.Sprintf("%T.offset (5) field write error: ", p), err)
 13842  	}
 13843  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13844  		return thrift.PrependError(fmt.Sprintf("%T write field end error 5:offset: ", p), err)
 13845  	}
 13846  	return err
 13847  }
 13848  
 13849  func (p *ZRangeByScoreWithScoresArgs) writeField6(ctx context.Context, tp thrift.TProtocol) (err error) {
 13850  	if err := tp.WriteFieldBegin(ctx, "count", thrift.I64, 6); err != nil {
 13851  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:count: ", p), err)
 13852  	}
 13853  	if err := tp.WriteI64(ctx, int64(p.Count)); err != nil {
 13854  		return thrift.PrependError(fmt.Sprintf("%T.count (6) field write error: ", p), err)
 13855  	}
 13856  	if err := tp.WriteFieldEnd(ctx); err != nil {
 13857  		return thrift.PrependError(fmt.Sprintf("%T write field end error 6:count: ", p), err)
 13858  	}
 13859  	return err
 13860  }
 13861  
 13862  func (p *ZRangeByScoreWithScoresArgs) String() string {
 13863  	if p == nil {
 13864  		return "<nil>"
 13865  	}
 13866  	return fmt.Sprintf("ZRangeByScoreWithScoresArgs(%+v)", *p)
 13867  }
 13868  
 13869  // Attributes:
 13870  //  - Success
 13871  type ZRangeByScoreWithScoresResult struct {
 13872  	Success *ZResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 13873  }
 13874  
 13875  func NewZRangeByScoreWithScoresResult() *ZRangeByScoreWithScoresResult {
 13876  	return &ZRangeByScoreWithScoresResult{}
 13877  }
 13878  
 13879  var ZRangeByScoreWithScoresResult_Success_DEFAULT *ZResponse
 13880  
 13881  func (p *ZRangeByScoreWithScoresResult) GetSuccess() *ZResponse {
 13882  	if !p.IsSetSuccess() {
 13883  		return ZRangeByScoreWithScoresResult_Success_DEFAULT
 13884  	}
 13885  	return p.Success
 13886  }
 13887  func (p *ZRangeByScoreWithScoresResult) IsSetSuccess() bool {
 13888  	return p.Success != nil
 13889  }
 13890  
 13891  func (p *ZRangeByScoreWithScoresResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 13892  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 13893  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 13894  	}
 13895  
 13896  	for {
 13897  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 13898  		if err != nil {
 13899  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 13900  		}
 13901  		if fieldTypeId == thrift.STOP {
 13902  			break
 13903  		}
 13904  		switch fieldId {
 13905  		case 0:
 13906  			if fieldTypeId == thrift.STRUCT {
 13907  				if err := p.ReadField0(ctx, tp); err != nil {
 13908  					return err
 13909  				}
 13910  			} else {
 13911  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13912  					return err
 13913  				}
 13914  			}
 13915  		default:
 13916  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 13917  				return err
 13918  			}
 13919  		}
 13920  		if err := tp.ReadFieldEnd(ctx); err != nil {
 13921  			return err
 13922  		}
 13923  	}
 13924  	if err := tp.ReadStructEnd(ctx); err != nil {
 13925  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 13926  	}
 13927  	return nil
 13928  }
 13929  
 13930  func (p *ZRangeByScoreWithScoresResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 13931  	p.Success = &ZResponse{}
 13932  	if err := p.Success.Read(ctx, tp); err != nil {
 13933  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 13934  	}
 13935  	return nil
 13936  }
 13937  
 13938  func (p *ZRangeByScoreWithScoresResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 13939  	if err := tp.WriteStructBegin(ctx, "ZRangeByScoreWithScores_result"); err != nil {
 13940  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 13941  	}
 13942  	if p != nil {
 13943  		if err := p.writeField0(ctx, tp); err != nil {
 13944  			return err
 13945  		}
 13946  	}
 13947  	if err := tp.WriteFieldStop(ctx); err != nil {
 13948  		return thrift.PrependError("write field stop error: ", err)
 13949  	}
 13950  	if err := tp.WriteStructEnd(ctx); err != nil {
 13951  		return thrift.PrependError("write struct stop error: ", err)
 13952  	}
 13953  	return nil
 13954  }
 13955  
 13956  func (p *ZRangeByScoreWithScoresResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 13957  	if p.IsSetSuccess() {
 13958  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 13959  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 13960  		}
 13961  		if err := p.Success.Write(ctx, tp); err != nil {
 13962  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 13963  		}
 13964  		if err := tp.WriteFieldEnd(ctx); err != nil {
 13965  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 13966  		}
 13967  	}
 13968  	return err
 13969  }
 13970  
 13971  func (p *ZRangeByScoreWithScoresResult) String() string {
 13972  	if p == nil {
 13973  		return "<nil>"
 13974  	}
 13975  	return fmt.Sprintf("ZRangeByScoreWithScoresResult(%+v)", *p)
 13976  }
 13977  
 13978  // Attributes:
 13979  //  - Appid
 13980  //  - Key
 13981  //  - Member
 13982  type ZRemArgs struct {
 13983  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 13984  	Key    string `thrift:"key,2" db:"key" json:"key"`
 13985  	Member string `thrift:"member,3" db:"member" json:"member"`
 13986  }
 13987  
 13988  func NewZRemArgs() *ZRemArgs {
 13989  	return &ZRemArgs{}
 13990  }
 13991  
 13992  func (p *ZRemArgs) GetAppid() string {
 13993  	return p.Appid
 13994  }
 13995  
 13996  func (p *ZRemArgs) GetKey() string {
 13997  	return p.Key
 13998  }
 13999  
 14000  func (p *ZRemArgs) GetMember() string {
 14001  	return p.Member
 14002  }
 14003  func (p *ZRemArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 14004  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14005  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14006  	}
 14007  
 14008  	for {
 14009  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14010  		if err != nil {
 14011  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14012  		}
 14013  		if fieldTypeId == thrift.STOP {
 14014  			break
 14015  		}
 14016  		switch fieldId {
 14017  		case 1:
 14018  			if fieldTypeId == thrift.STRING {
 14019  				if err := p.ReadField1(ctx, tp); err != nil {
 14020  					return err
 14021  				}
 14022  			} else {
 14023  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14024  					return err
 14025  				}
 14026  			}
 14027  		case 2:
 14028  			if fieldTypeId == thrift.STRING {
 14029  				if err := p.ReadField2(ctx, tp); err != nil {
 14030  					return err
 14031  				}
 14032  			} else {
 14033  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14034  					return err
 14035  				}
 14036  			}
 14037  		case 3:
 14038  			if fieldTypeId == thrift.STRING {
 14039  				if err := p.ReadField3(ctx, tp); err != nil {
 14040  					return err
 14041  				}
 14042  			} else {
 14043  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14044  					return err
 14045  				}
 14046  			}
 14047  		default:
 14048  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14049  				return err
 14050  			}
 14051  		}
 14052  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14053  			return err
 14054  		}
 14055  	}
 14056  	if err := tp.ReadStructEnd(ctx); err != nil {
 14057  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14058  	}
 14059  	return nil
 14060  }
 14061  
 14062  func (p *ZRemArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 14063  	if v, err := tp.ReadString(ctx); err != nil {
 14064  		return thrift.PrependError("error reading field 1: ", err)
 14065  	} else {
 14066  		p.Appid = v
 14067  	}
 14068  	return nil
 14069  }
 14070  
 14071  func (p *ZRemArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 14072  	if v, err := tp.ReadString(ctx); err != nil {
 14073  		return thrift.PrependError("error reading field 2: ", err)
 14074  	} else {
 14075  		p.Key = v
 14076  	}
 14077  	return nil
 14078  }
 14079  
 14080  func (p *ZRemArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 14081  	if v, err := tp.ReadString(ctx); err != nil {
 14082  		return thrift.PrependError("error reading field 3: ", err)
 14083  	} else {
 14084  		p.Member = v
 14085  	}
 14086  	return nil
 14087  }
 14088  
 14089  func (p *ZRemArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 14090  	if err := tp.WriteStructBegin(ctx, "ZRem_args"); err != nil {
 14091  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14092  	}
 14093  	if p != nil {
 14094  		if err := p.writeField1(ctx, tp); err != nil {
 14095  			return err
 14096  		}
 14097  		if err := p.writeField2(ctx, tp); err != nil {
 14098  			return err
 14099  		}
 14100  		if err := p.writeField3(ctx, tp); err != nil {
 14101  			return err
 14102  		}
 14103  	}
 14104  	if err := tp.WriteFieldStop(ctx); err != nil {
 14105  		return thrift.PrependError("write field stop error: ", err)
 14106  	}
 14107  	if err := tp.WriteStructEnd(ctx); err != nil {
 14108  		return thrift.PrependError("write struct stop error: ", err)
 14109  	}
 14110  	return nil
 14111  }
 14112  
 14113  func (p *ZRemArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 14114  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 14115  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 14116  	}
 14117  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 14118  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 14119  	}
 14120  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14121  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 14122  	}
 14123  	return err
 14124  }
 14125  
 14126  func (p *ZRemArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 14127  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 14128  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 14129  	}
 14130  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 14131  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 14132  	}
 14133  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14134  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 14135  	}
 14136  	return err
 14137  }
 14138  
 14139  func (p *ZRemArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 14140  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 3); err != nil {
 14141  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 14142  	}
 14143  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 14144  		return thrift.PrependError(fmt.Sprintf("%T.member (3) field write error: ", p), err)
 14145  	}
 14146  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14147  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 14148  	}
 14149  	return err
 14150  }
 14151  
 14152  func (p *ZRemArgs) String() string {
 14153  	if p == nil {
 14154  		return "<nil>"
 14155  	}
 14156  	return fmt.Sprintf("ZRemArgs(%+v)", *p)
 14157  }
 14158  
 14159  // Attributes:
 14160  //  - Success
 14161  type ZRemResult struct {
 14162  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 14163  }
 14164  
 14165  func NewZRemResult() *ZRemResult {
 14166  	return &ZRemResult{}
 14167  }
 14168  
 14169  var ZRemResult_Success_DEFAULT *IntResponse
 14170  
 14171  func (p *ZRemResult) GetSuccess() *IntResponse {
 14172  	if !p.IsSetSuccess() {
 14173  		return ZRemResult_Success_DEFAULT
 14174  	}
 14175  	return p.Success
 14176  }
 14177  func (p *ZRemResult) IsSetSuccess() bool {
 14178  	return p.Success != nil
 14179  }
 14180  
 14181  func (p *ZRemResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 14182  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14183  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14184  	}
 14185  
 14186  	for {
 14187  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14188  		if err != nil {
 14189  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14190  		}
 14191  		if fieldTypeId == thrift.STOP {
 14192  			break
 14193  		}
 14194  		switch fieldId {
 14195  		case 0:
 14196  			if fieldTypeId == thrift.STRUCT {
 14197  				if err := p.ReadField0(ctx, tp); err != nil {
 14198  					return err
 14199  				}
 14200  			} else {
 14201  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14202  					return err
 14203  				}
 14204  			}
 14205  		default:
 14206  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14207  				return err
 14208  			}
 14209  		}
 14210  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14211  			return err
 14212  		}
 14213  	}
 14214  	if err := tp.ReadStructEnd(ctx); err != nil {
 14215  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14216  	}
 14217  	return nil
 14218  }
 14219  
 14220  func (p *ZRemResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 14221  	p.Success = &IntResponse{}
 14222  	if err := p.Success.Read(ctx, tp); err != nil {
 14223  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 14224  	}
 14225  	return nil
 14226  }
 14227  
 14228  func (p *ZRemResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 14229  	if err := tp.WriteStructBegin(ctx, "ZRem_result"); err != nil {
 14230  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14231  	}
 14232  	if p != nil {
 14233  		if err := p.writeField0(ctx, tp); err != nil {
 14234  			return err
 14235  		}
 14236  	}
 14237  	if err := tp.WriteFieldStop(ctx); err != nil {
 14238  		return thrift.PrependError("write field stop error: ", err)
 14239  	}
 14240  	if err := tp.WriteStructEnd(ctx); err != nil {
 14241  		return thrift.PrependError("write struct stop error: ", err)
 14242  	}
 14243  	return nil
 14244  }
 14245  
 14246  func (p *ZRemResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 14247  	if p.IsSetSuccess() {
 14248  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 14249  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 14250  		}
 14251  		if err := p.Success.Write(ctx, tp); err != nil {
 14252  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 14253  		}
 14254  		if err := tp.WriteFieldEnd(ctx); err != nil {
 14255  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 14256  		}
 14257  	}
 14258  	return err
 14259  }
 14260  
 14261  func (p *ZRemResult) String() string {
 14262  	if p == nil {
 14263  		return "<nil>"
 14264  	}
 14265  	return fmt.Sprintf("ZRemResult(%+v)", *p)
 14266  }
 14267  
 14268  // Attributes:
 14269  //  - Appid
 14270  //  - Key
 14271  //  - Members
 14272  type MzRemArgs struct {
 14273  	Appid   string   `thrift:"appid,1" db:"appid" json:"appid"`
 14274  	Key     string   `thrift:"key,2" db:"key" json:"key"`
 14275  	Members []string `thrift:"members,3" db:"members" json:"members"`
 14276  }
 14277  
 14278  func NewMZRemArgs() *MzRemArgs {
 14279  	return &MzRemArgs{}
 14280  }
 14281  
 14282  func (p *MzRemArgs) GetAppid() string {
 14283  	return p.Appid
 14284  }
 14285  
 14286  func (p *MzRemArgs) GetKey() string {
 14287  	return p.Key
 14288  }
 14289  
 14290  func (p *MzRemArgs) GetMembers() []string {
 14291  	return p.Members
 14292  }
 14293  func (p *MzRemArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 14294  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14295  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14296  	}
 14297  
 14298  	for {
 14299  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14300  		if err != nil {
 14301  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14302  		}
 14303  		if fieldTypeId == thrift.STOP {
 14304  			break
 14305  		}
 14306  		switch fieldId {
 14307  		case 1:
 14308  			if fieldTypeId == thrift.STRING {
 14309  				if err := p.ReadField1(ctx, tp); err != nil {
 14310  					return err
 14311  				}
 14312  			} else {
 14313  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14314  					return err
 14315  				}
 14316  			}
 14317  		case 2:
 14318  			if fieldTypeId == thrift.STRING {
 14319  				if err := p.ReadField2(ctx, tp); err != nil {
 14320  					return err
 14321  				}
 14322  			} else {
 14323  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14324  					return err
 14325  				}
 14326  			}
 14327  		case 3:
 14328  			if fieldTypeId == thrift.LIST {
 14329  				if err := p.ReadField3(ctx, tp); err != nil {
 14330  					return err
 14331  				}
 14332  			} else {
 14333  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14334  					return err
 14335  				}
 14336  			}
 14337  		default:
 14338  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14339  				return err
 14340  			}
 14341  		}
 14342  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14343  			return err
 14344  		}
 14345  	}
 14346  	if err := tp.ReadStructEnd(ctx); err != nil {
 14347  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14348  	}
 14349  	return nil
 14350  }
 14351  
 14352  func (p *MzRemArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 14353  	if v, err := tp.ReadString(ctx); err != nil {
 14354  		return thrift.PrependError("error reading field 1: ", err)
 14355  	} else {
 14356  		p.Appid = v
 14357  	}
 14358  	return nil
 14359  }
 14360  
 14361  func (p *MzRemArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 14362  	if v, err := tp.ReadString(ctx); err != nil {
 14363  		return thrift.PrependError("error reading field 2: ", err)
 14364  	} else {
 14365  		p.Key = v
 14366  	}
 14367  	return nil
 14368  }
 14369  
 14370  func (p *MzRemArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 14371  	_, size, err := tp.ReadListBegin(ctx)
 14372  	if err != nil {
 14373  		return thrift.PrependError("error reading list begin: ", err)
 14374  	}
 14375  	tSlice := make([]string, 0, size)
 14376  	p.Members = tSlice
 14377  	for i := 0; i < size; i++ {
 14378  		var _elem194 string
 14379  		if v, err := tp.ReadString(ctx); err != nil {
 14380  			return thrift.PrependError("error reading field 0: ", err)
 14381  		} else {
 14382  			_elem194 = v
 14383  		}
 14384  		p.Members = append(p.Members, _elem194)
 14385  	}
 14386  	if err := tp.ReadListEnd(ctx); err != nil {
 14387  		return thrift.PrependError("error reading list end: ", err)
 14388  	}
 14389  	return nil
 14390  }
 14391  
 14392  func (p *MzRemArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 14393  	if err := tp.WriteStructBegin(ctx, "MZRem_args"); err != nil {
 14394  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14395  	}
 14396  	if p != nil {
 14397  		if err := p.writeField1(ctx, tp); err != nil {
 14398  			return err
 14399  		}
 14400  		if err := p.writeField2(ctx, tp); err != nil {
 14401  			return err
 14402  		}
 14403  		if err := p.writeField3(ctx, tp); err != nil {
 14404  			return err
 14405  		}
 14406  	}
 14407  	if err := tp.WriteFieldStop(ctx); err != nil {
 14408  		return thrift.PrependError("write field stop error: ", err)
 14409  	}
 14410  	if err := tp.WriteStructEnd(ctx); err != nil {
 14411  		return thrift.PrependError("write struct stop error: ", err)
 14412  	}
 14413  	return nil
 14414  }
 14415  
 14416  func (p *MzRemArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 14417  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 14418  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 14419  	}
 14420  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 14421  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 14422  	}
 14423  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14424  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 14425  	}
 14426  	return err
 14427  }
 14428  
 14429  func (p *MzRemArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 14430  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 14431  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 14432  	}
 14433  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 14434  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 14435  	}
 14436  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14437  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 14438  	}
 14439  	return err
 14440  }
 14441  
 14442  func (p *MzRemArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 14443  	if err := tp.WriteFieldBegin(ctx, "members", thrift.LIST, 3); err != nil {
 14444  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:members: ", p), err)
 14445  	}
 14446  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Members)); err != nil {
 14447  		return thrift.PrependError("error writing list begin: ", err)
 14448  	}
 14449  	for _, v := range p.Members {
 14450  		if err := tp.WriteString(ctx, string(v)); err != nil {
 14451  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 14452  		}
 14453  	}
 14454  	if err := tp.WriteListEnd(ctx); err != nil {
 14455  		return thrift.PrependError("error writing list end: ", err)
 14456  	}
 14457  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14458  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:members: ", p), err)
 14459  	}
 14460  	return err
 14461  }
 14462  
 14463  func (p *MzRemArgs) String() string {
 14464  	if p == nil {
 14465  		return "<nil>"
 14466  	}
 14467  	return fmt.Sprintf("MzRemArgs(%+v)", *p)
 14468  }
 14469  
 14470  // Attributes:
 14471  //  - Success
 14472  type MzRemResult struct {
 14473  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 14474  }
 14475  
 14476  func NewMZRemResult() *MzRemResult {
 14477  	return &MzRemResult{}
 14478  }
 14479  
 14480  var MZRemResult_Success_DEFAULT *IntResponse
 14481  
 14482  func (p *MzRemResult) GetSuccess() *IntResponse {
 14483  	if !p.IsSetSuccess() {
 14484  		return MZRemResult_Success_DEFAULT
 14485  	}
 14486  	return p.Success
 14487  }
 14488  func (p *MzRemResult) IsSetSuccess() bool {
 14489  	return p.Success != nil
 14490  }
 14491  
 14492  func (p *MzRemResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 14493  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14494  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14495  	}
 14496  
 14497  	for {
 14498  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14499  		if err != nil {
 14500  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14501  		}
 14502  		if fieldTypeId == thrift.STOP {
 14503  			break
 14504  		}
 14505  		switch fieldId {
 14506  		case 0:
 14507  			if fieldTypeId == thrift.STRUCT {
 14508  				if err := p.ReadField0(ctx, tp); err != nil {
 14509  					return err
 14510  				}
 14511  			} else {
 14512  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14513  					return err
 14514  				}
 14515  			}
 14516  		default:
 14517  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14518  				return err
 14519  			}
 14520  		}
 14521  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14522  			return err
 14523  		}
 14524  	}
 14525  	if err := tp.ReadStructEnd(ctx); err != nil {
 14526  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14527  	}
 14528  	return nil
 14529  }
 14530  
 14531  func (p *MzRemResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 14532  	p.Success = &IntResponse{}
 14533  	if err := p.Success.Read(ctx, tp); err != nil {
 14534  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 14535  	}
 14536  	return nil
 14537  }
 14538  
 14539  func (p *MzRemResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 14540  	if err := tp.WriteStructBegin(ctx, "MZRem_result"); err != nil {
 14541  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14542  	}
 14543  	if p != nil {
 14544  		if err := p.writeField0(ctx, tp); err != nil {
 14545  			return err
 14546  		}
 14547  	}
 14548  	if err := tp.WriteFieldStop(ctx); err != nil {
 14549  		return thrift.PrependError("write field stop error: ", err)
 14550  	}
 14551  	if err := tp.WriteStructEnd(ctx); err != nil {
 14552  		return thrift.PrependError("write struct stop error: ", err)
 14553  	}
 14554  	return nil
 14555  }
 14556  
 14557  func (p *MzRemResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 14558  	if p.IsSetSuccess() {
 14559  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 14560  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 14561  		}
 14562  		if err := p.Success.Write(ctx, tp); err != nil {
 14563  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 14564  		}
 14565  		if err := tp.WriteFieldEnd(ctx); err != nil {
 14566  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 14567  		}
 14568  	}
 14569  	return err
 14570  }
 14571  
 14572  func (p *MzRemResult) String() string {
 14573  	if p == nil {
 14574  		return "<nil>"
 14575  	}
 14576  	return fmt.Sprintf("MzRemResult(%+v)", *p)
 14577  }
 14578  
 14579  // Attributes:
 14580  //  - Appid
 14581  //  - Key
 14582  //  - Start
 14583  //  - Stop
 14584  type ZRemRangeByRankArgs struct {
 14585  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 14586  	Key   string `thrift:"key,2" db:"key" json:"key"`
 14587  	Start int64  `thrift:"start,3" db:"start" json:"start"`
 14588  	Stop  int64  `thrift:"stop,4" db:"stop" json:"stop"`
 14589  }
 14590  
 14591  func NewZRemRangeByRankArgs() *ZRemRangeByRankArgs {
 14592  	return &ZRemRangeByRankArgs{}
 14593  }
 14594  
 14595  func (p *ZRemRangeByRankArgs) GetAppid() string {
 14596  	return p.Appid
 14597  }
 14598  
 14599  func (p *ZRemRangeByRankArgs) GetKey() string {
 14600  	return p.Key
 14601  }
 14602  
 14603  func (p *ZRemRangeByRankArgs) GetStart() int64 {
 14604  	return p.Start
 14605  }
 14606  
 14607  func (p *ZRemRangeByRankArgs) GetStop() int64 {
 14608  	return p.Stop
 14609  }
 14610  func (p *ZRemRangeByRankArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 14611  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14612  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14613  	}
 14614  
 14615  	for {
 14616  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14617  		if err != nil {
 14618  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14619  		}
 14620  		if fieldTypeId == thrift.STOP {
 14621  			break
 14622  		}
 14623  		switch fieldId {
 14624  		case 1:
 14625  			if fieldTypeId == thrift.STRING {
 14626  				if err := p.ReadField1(ctx, tp); err != nil {
 14627  					return err
 14628  				}
 14629  			} else {
 14630  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14631  					return err
 14632  				}
 14633  			}
 14634  		case 2:
 14635  			if fieldTypeId == thrift.STRING {
 14636  				if err := p.ReadField2(ctx, tp); err != nil {
 14637  					return err
 14638  				}
 14639  			} else {
 14640  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14641  					return err
 14642  				}
 14643  			}
 14644  		case 3:
 14645  			if fieldTypeId == thrift.I64 {
 14646  				if err := p.ReadField3(ctx, tp); err != nil {
 14647  					return err
 14648  				}
 14649  			} else {
 14650  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14651  					return err
 14652  				}
 14653  			}
 14654  		case 4:
 14655  			if fieldTypeId == thrift.I64 {
 14656  				if err := p.ReadField4(ctx, tp); err != nil {
 14657  					return err
 14658  				}
 14659  			} else {
 14660  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14661  					return err
 14662  				}
 14663  			}
 14664  		default:
 14665  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14666  				return err
 14667  			}
 14668  		}
 14669  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14670  			return err
 14671  		}
 14672  	}
 14673  	if err := tp.ReadStructEnd(ctx); err != nil {
 14674  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14675  	}
 14676  	return nil
 14677  }
 14678  
 14679  func (p *ZRemRangeByRankArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 14680  	if v, err := tp.ReadString(ctx); err != nil {
 14681  		return thrift.PrependError("error reading field 1: ", err)
 14682  	} else {
 14683  		p.Appid = v
 14684  	}
 14685  	return nil
 14686  }
 14687  
 14688  func (p *ZRemRangeByRankArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 14689  	if v, err := tp.ReadString(ctx); err != nil {
 14690  		return thrift.PrependError("error reading field 2: ", err)
 14691  	} else {
 14692  		p.Key = v
 14693  	}
 14694  	return nil
 14695  }
 14696  
 14697  func (p *ZRemRangeByRankArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 14698  	if v, err := tp.ReadI64(ctx); err != nil {
 14699  		return thrift.PrependError("error reading field 3: ", err)
 14700  	} else {
 14701  		p.Start = v
 14702  	}
 14703  	return nil
 14704  }
 14705  
 14706  func (p *ZRemRangeByRankArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 14707  	if v, err := tp.ReadI64(ctx); err != nil {
 14708  		return thrift.PrependError("error reading field 4: ", err)
 14709  	} else {
 14710  		p.Stop = v
 14711  	}
 14712  	return nil
 14713  }
 14714  
 14715  func (p *ZRemRangeByRankArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 14716  	if err := tp.WriteStructBegin(ctx, "ZRemRangeByRank_args"); err != nil {
 14717  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14718  	}
 14719  	if p != nil {
 14720  		if err := p.writeField1(ctx, tp); err != nil {
 14721  			return err
 14722  		}
 14723  		if err := p.writeField2(ctx, tp); err != nil {
 14724  			return err
 14725  		}
 14726  		if err := p.writeField3(ctx, tp); err != nil {
 14727  			return err
 14728  		}
 14729  		if err := p.writeField4(ctx, tp); err != nil {
 14730  			return err
 14731  		}
 14732  	}
 14733  	if err := tp.WriteFieldStop(ctx); err != nil {
 14734  		return thrift.PrependError("write field stop error: ", err)
 14735  	}
 14736  	if err := tp.WriteStructEnd(ctx); err != nil {
 14737  		return thrift.PrependError("write struct stop error: ", err)
 14738  	}
 14739  	return nil
 14740  }
 14741  
 14742  func (p *ZRemRangeByRankArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 14743  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 14744  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 14745  	}
 14746  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 14747  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 14748  	}
 14749  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14750  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 14751  	}
 14752  	return err
 14753  }
 14754  
 14755  func (p *ZRemRangeByRankArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 14756  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 14757  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 14758  	}
 14759  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 14760  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 14761  	}
 14762  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14763  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 14764  	}
 14765  	return err
 14766  }
 14767  
 14768  func (p *ZRemRangeByRankArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 14769  	if err := tp.WriteFieldBegin(ctx, "start", thrift.I64, 3); err != nil {
 14770  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:start: ", p), err)
 14771  	}
 14772  	if err := tp.WriteI64(ctx, int64(p.Start)); err != nil {
 14773  		return thrift.PrependError(fmt.Sprintf("%T.start (3) field write error: ", p), err)
 14774  	}
 14775  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14776  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:start: ", p), err)
 14777  	}
 14778  	return err
 14779  }
 14780  
 14781  func (p *ZRemRangeByRankArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 14782  	if err := tp.WriteFieldBegin(ctx, "stop", thrift.I64, 4); err != nil {
 14783  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:stop: ", p), err)
 14784  	}
 14785  	if err := tp.WriteI64(ctx, int64(p.Stop)); err != nil {
 14786  		return thrift.PrependError(fmt.Sprintf("%T.stop (4) field write error: ", p), err)
 14787  	}
 14788  	if err := tp.WriteFieldEnd(ctx); err != nil {
 14789  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:stop: ", p), err)
 14790  	}
 14791  	return err
 14792  }
 14793  
 14794  func (p *ZRemRangeByRankArgs) String() string {
 14795  	if p == nil {
 14796  		return "<nil>"
 14797  	}
 14798  	return fmt.Sprintf("ZRemRangeByRankArgs(%+v)", *p)
 14799  }
 14800  
 14801  // Attributes:
 14802  //  - Success
 14803  type ZRemRangeByRankResult struct {
 14804  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 14805  }
 14806  
 14807  func NewZRemRangeByRankResult() *ZRemRangeByRankResult {
 14808  	return &ZRemRangeByRankResult{}
 14809  }
 14810  
 14811  var ZRemRangeByRankResult_Success_DEFAULT *IntResponse
 14812  
 14813  func (p *ZRemRangeByRankResult) GetSuccess() *IntResponse {
 14814  	if !p.IsSetSuccess() {
 14815  		return ZRemRangeByRankResult_Success_DEFAULT
 14816  	}
 14817  	return p.Success
 14818  }
 14819  func (p *ZRemRangeByRankResult) IsSetSuccess() bool {
 14820  	return p.Success != nil
 14821  }
 14822  
 14823  func (p *ZRemRangeByRankResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 14824  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14825  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14826  	}
 14827  
 14828  	for {
 14829  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14830  		if err != nil {
 14831  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14832  		}
 14833  		if fieldTypeId == thrift.STOP {
 14834  			break
 14835  		}
 14836  		switch fieldId {
 14837  		case 0:
 14838  			if fieldTypeId == thrift.STRUCT {
 14839  				if err := p.ReadField0(ctx, tp); err != nil {
 14840  					return err
 14841  				}
 14842  			} else {
 14843  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14844  					return err
 14845  				}
 14846  			}
 14847  		default:
 14848  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14849  				return err
 14850  			}
 14851  		}
 14852  		if err := tp.ReadFieldEnd(ctx); err != nil {
 14853  			return err
 14854  		}
 14855  	}
 14856  	if err := tp.ReadStructEnd(ctx); err != nil {
 14857  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 14858  	}
 14859  	return nil
 14860  }
 14861  
 14862  func (p *ZRemRangeByRankResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 14863  	p.Success = &IntResponse{}
 14864  	if err := p.Success.Read(ctx, tp); err != nil {
 14865  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 14866  	}
 14867  	return nil
 14868  }
 14869  
 14870  func (p *ZRemRangeByRankResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 14871  	if err := tp.WriteStructBegin(ctx, "ZRemRangeByRank_result"); err != nil {
 14872  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 14873  	}
 14874  	if p != nil {
 14875  		if err := p.writeField0(ctx, tp); err != nil {
 14876  			return err
 14877  		}
 14878  	}
 14879  	if err := tp.WriteFieldStop(ctx); err != nil {
 14880  		return thrift.PrependError("write field stop error: ", err)
 14881  	}
 14882  	if err := tp.WriteStructEnd(ctx); err != nil {
 14883  		return thrift.PrependError("write struct stop error: ", err)
 14884  	}
 14885  	return nil
 14886  }
 14887  
 14888  func (p *ZRemRangeByRankResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 14889  	if p.IsSetSuccess() {
 14890  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 14891  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 14892  		}
 14893  		if err := p.Success.Write(ctx, tp); err != nil {
 14894  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 14895  		}
 14896  		if err := tp.WriteFieldEnd(ctx); err != nil {
 14897  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 14898  		}
 14899  	}
 14900  	return err
 14901  }
 14902  
 14903  func (p *ZRemRangeByRankResult) String() string {
 14904  	if p == nil {
 14905  		return "<nil>"
 14906  	}
 14907  	return fmt.Sprintf("ZRemRangeByRankResult(%+v)", *p)
 14908  }
 14909  
 14910  // Attributes:
 14911  //  - Appid
 14912  //  - Key
 14913  //  - Min
 14914  //  - Max
 14915  type ZRemRangeByScoreArgs struct {
 14916  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 14917  	Key   string `thrift:"key,2" db:"key" json:"key"`
 14918  	Min   string `thrift:"min,3" db:"min" json:"min"`
 14919  	Max   string `thrift:"max,4" db:"max" json:"max"`
 14920  }
 14921  
 14922  func NewZRemRangeByScoreArgs() *ZRemRangeByScoreArgs {
 14923  	return &ZRemRangeByScoreArgs{}
 14924  }
 14925  
 14926  func (p *ZRemRangeByScoreArgs) GetAppid() string {
 14927  	return p.Appid
 14928  }
 14929  
 14930  func (p *ZRemRangeByScoreArgs) GetKey() string {
 14931  	return p.Key
 14932  }
 14933  
 14934  func (p *ZRemRangeByScoreArgs) GetMin() string {
 14935  	return p.Min
 14936  }
 14937  
 14938  func (p *ZRemRangeByScoreArgs) GetMax() string {
 14939  	return p.Max
 14940  }
 14941  func (p *ZRemRangeByScoreArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 14942  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 14943  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 14944  	}
 14945  
 14946  	for {
 14947  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 14948  		if err != nil {
 14949  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 14950  		}
 14951  		if fieldTypeId == thrift.STOP {
 14952  			break
 14953  		}
 14954  		switch fieldId {
 14955  		case 1:
 14956  			if fieldTypeId == thrift.STRING {
 14957  				if err := p.ReadField1(ctx, tp); err != nil {
 14958  					return err
 14959  				}
 14960  			} else {
 14961  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14962  					return err
 14963  				}
 14964  			}
 14965  		case 2:
 14966  			if fieldTypeId == thrift.STRING {
 14967  				if err := p.ReadField2(ctx, tp); err != nil {
 14968  					return err
 14969  				}
 14970  			} else {
 14971  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14972  					return err
 14973  				}
 14974  			}
 14975  		case 3:
 14976  			if fieldTypeId == thrift.STRING {
 14977  				if err := p.ReadField3(ctx, tp); err != nil {
 14978  					return err
 14979  				}
 14980  			} else {
 14981  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14982  					return err
 14983  				}
 14984  			}
 14985  		case 4:
 14986  			if fieldTypeId == thrift.STRING {
 14987  				if err := p.ReadField4(ctx, tp); err != nil {
 14988  					return err
 14989  				}
 14990  			} else {
 14991  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14992  					return err
 14993  				}
 14994  			}
 14995  		default:
 14996  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 14997  				return err
 14998  			}
 14999  		}
 15000  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15001  			return err
 15002  		}
 15003  	}
 15004  	if err := tp.ReadStructEnd(ctx); err != nil {
 15005  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15006  	}
 15007  	return nil
 15008  }
 15009  
 15010  func (p *ZRemRangeByScoreArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 15011  	if v, err := tp.ReadString(ctx); err != nil {
 15012  		return thrift.PrependError("error reading field 1: ", err)
 15013  	} else {
 15014  		p.Appid = v
 15015  	}
 15016  	return nil
 15017  }
 15018  
 15019  func (p *ZRemRangeByScoreArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 15020  	if v, err := tp.ReadString(ctx); err != nil {
 15021  		return thrift.PrependError("error reading field 2: ", err)
 15022  	} else {
 15023  		p.Key = v
 15024  	}
 15025  	return nil
 15026  }
 15027  
 15028  func (p *ZRemRangeByScoreArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 15029  	if v, err := tp.ReadString(ctx); err != nil {
 15030  		return thrift.PrependError("error reading field 3: ", err)
 15031  	} else {
 15032  		p.Min = v
 15033  	}
 15034  	return nil
 15035  }
 15036  
 15037  func (p *ZRemRangeByScoreArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 15038  	if v, err := tp.ReadString(ctx); err != nil {
 15039  		return thrift.PrependError("error reading field 4: ", err)
 15040  	} else {
 15041  		p.Max = v
 15042  	}
 15043  	return nil
 15044  }
 15045  
 15046  func (p *ZRemRangeByScoreArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 15047  	if err := tp.WriteStructBegin(ctx, "ZRemRangeByScore_args"); err != nil {
 15048  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15049  	}
 15050  	if p != nil {
 15051  		if err := p.writeField1(ctx, tp); err != nil {
 15052  			return err
 15053  		}
 15054  		if err := p.writeField2(ctx, tp); err != nil {
 15055  			return err
 15056  		}
 15057  		if err := p.writeField3(ctx, tp); err != nil {
 15058  			return err
 15059  		}
 15060  		if err := p.writeField4(ctx, tp); err != nil {
 15061  			return err
 15062  		}
 15063  	}
 15064  	if err := tp.WriteFieldStop(ctx); err != nil {
 15065  		return thrift.PrependError("write field stop error: ", err)
 15066  	}
 15067  	if err := tp.WriteStructEnd(ctx); err != nil {
 15068  		return thrift.PrependError("write struct stop error: ", err)
 15069  	}
 15070  	return nil
 15071  }
 15072  
 15073  func (p *ZRemRangeByScoreArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 15074  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 15075  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 15076  	}
 15077  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 15078  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 15079  	}
 15080  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15081  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 15082  	}
 15083  	return err
 15084  }
 15085  
 15086  func (p *ZRemRangeByScoreArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 15087  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 15088  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 15089  	}
 15090  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 15091  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 15092  	}
 15093  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15094  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 15095  	}
 15096  	return err
 15097  }
 15098  
 15099  func (p *ZRemRangeByScoreArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 15100  	if err := tp.WriteFieldBegin(ctx, "min", thrift.STRING, 3); err != nil {
 15101  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:min: ", p), err)
 15102  	}
 15103  	if err := tp.WriteString(ctx, string(p.Min)); err != nil {
 15104  		return thrift.PrependError(fmt.Sprintf("%T.min (3) field write error: ", p), err)
 15105  	}
 15106  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15107  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:min: ", p), err)
 15108  	}
 15109  	return err
 15110  }
 15111  
 15112  func (p *ZRemRangeByScoreArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 15113  	if err := tp.WriteFieldBegin(ctx, "max", thrift.STRING, 4); err != nil {
 15114  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:max: ", p), err)
 15115  	}
 15116  	if err := tp.WriteString(ctx, string(p.Max)); err != nil {
 15117  		return thrift.PrependError(fmt.Sprintf("%T.max (4) field write error: ", p), err)
 15118  	}
 15119  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15120  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:max: ", p), err)
 15121  	}
 15122  	return err
 15123  }
 15124  
 15125  func (p *ZRemRangeByScoreArgs) String() string {
 15126  	if p == nil {
 15127  		return "<nil>"
 15128  	}
 15129  	return fmt.Sprintf("ZRemRangeByScoreArgs(%+v)", *p)
 15130  }
 15131  
 15132  // Attributes:
 15133  //  - Success
 15134  type ZRemRangeByScoreResult struct {
 15135  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 15136  }
 15137  
 15138  func NewZRemRangeByScoreResult() *ZRemRangeByScoreResult {
 15139  	return &ZRemRangeByScoreResult{}
 15140  }
 15141  
 15142  var ZRemRangeByScoreResult_Success_DEFAULT *IntResponse
 15143  
 15144  func (p *ZRemRangeByScoreResult) GetSuccess() *IntResponse {
 15145  	if !p.IsSetSuccess() {
 15146  		return ZRemRangeByScoreResult_Success_DEFAULT
 15147  	}
 15148  	return p.Success
 15149  }
 15150  func (p *ZRemRangeByScoreResult) IsSetSuccess() bool {
 15151  	return p.Success != nil
 15152  }
 15153  
 15154  func (p *ZRemRangeByScoreResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 15155  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15156  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15157  	}
 15158  
 15159  	for {
 15160  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15161  		if err != nil {
 15162  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15163  		}
 15164  		if fieldTypeId == thrift.STOP {
 15165  			break
 15166  		}
 15167  		switch fieldId {
 15168  		case 0:
 15169  			if fieldTypeId == thrift.STRUCT {
 15170  				if err := p.ReadField0(ctx, tp); err != nil {
 15171  					return err
 15172  				}
 15173  			} else {
 15174  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15175  					return err
 15176  				}
 15177  			}
 15178  		default:
 15179  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15180  				return err
 15181  			}
 15182  		}
 15183  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15184  			return err
 15185  		}
 15186  	}
 15187  	if err := tp.ReadStructEnd(ctx); err != nil {
 15188  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15189  	}
 15190  	return nil
 15191  }
 15192  
 15193  func (p *ZRemRangeByScoreResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 15194  	p.Success = &IntResponse{}
 15195  	if err := p.Success.Read(ctx, tp); err != nil {
 15196  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 15197  	}
 15198  	return nil
 15199  }
 15200  
 15201  func (p *ZRemRangeByScoreResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 15202  	if err := tp.WriteStructBegin(ctx, "ZRemRangeByScore_result"); err != nil {
 15203  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15204  	}
 15205  	if p != nil {
 15206  		if err := p.writeField0(ctx, tp); err != nil {
 15207  			return err
 15208  		}
 15209  	}
 15210  	if err := tp.WriteFieldStop(ctx); err != nil {
 15211  		return thrift.PrependError("write field stop error: ", err)
 15212  	}
 15213  	if err := tp.WriteStructEnd(ctx); err != nil {
 15214  		return thrift.PrependError("write struct stop error: ", err)
 15215  	}
 15216  	return nil
 15217  }
 15218  
 15219  func (p *ZRemRangeByScoreResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 15220  	if p.IsSetSuccess() {
 15221  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 15222  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 15223  		}
 15224  		if err := p.Success.Write(ctx, tp); err != nil {
 15225  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 15226  		}
 15227  		if err := tp.WriteFieldEnd(ctx); err != nil {
 15228  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 15229  		}
 15230  	}
 15231  	return err
 15232  }
 15233  
 15234  func (p *ZRemRangeByScoreResult) String() string {
 15235  	if p == nil {
 15236  		return "<nil>"
 15237  	}
 15238  	return fmt.Sprintf("ZRemRangeByScoreResult(%+v)", *p)
 15239  }
 15240  
 15241  // Attributes:
 15242  //  - Appid
 15243  //  - Key
 15244  //  - Increment
 15245  //  - Member
 15246  type ZIncrByArgs struct {
 15247  	Appid     string  `thrift:"appid,1" db:"appid" json:"appid"`
 15248  	Key       string  `thrift:"key,2" db:"key" json:"key"`
 15249  	Increment float64 `thrift:"increment,3" db:"increment" json:"increment"`
 15250  	Member    string  `thrift:"member,4" db:"member" json:"member"`
 15251  }
 15252  
 15253  func NewZIncrByArgs() *ZIncrByArgs {
 15254  	return &ZIncrByArgs{}
 15255  }
 15256  
 15257  func (p *ZIncrByArgs) GetAppid() string {
 15258  	return p.Appid
 15259  }
 15260  
 15261  func (p *ZIncrByArgs) GetKey() string {
 15262  	return p.Key
 15263  }
 15264  
 15265  func (p *ZIncrByArgs) GetIncrement() float64 {
 15266  	return p.Increment
 15267  }
 15268  
 15269  func (p *ZIncrByArgs) GetMember() string {
 15270  	return p.Member
 15271  }
 15272  func (p *ZIncrByArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 15273  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15274  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15275  	}
 15276  
 15277  	for {
 15278  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15279  		if err != nil {
 15280  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15281  		}
 15282  		if fieldTypeId == thrift.STOP {
 15283  			break
 15284  		}
 15285  		switch fieldId {
 15286  		case 1:
 15287  			if fieldTypeId == thrift.STRING {
 15288  				if err := p.ReadField1(ctx, tp); err != nil {
 15289  					return err
 15290  				}
 15291  			} else {
 15292  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15293  					return err
 15294  				}
 15295  			}
 15296  		case 2:
 15297  			if fieldTypeId == thrift.STRING {
 15298  				if err := p.ReadField2(ctx, tp); err != nil {
 15299  					return err
 15300  				}
 15301  			} else {
 15302  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15303  					return err
 15304  				}
 15305  			}
 15306  		case 3:
 15307  			if fieldTypeId == thrift.DOUBLE {
 15308  				if err := p.ReadField3(ctx, tp); err != nil {
 15309  					return err
 15310  				}
 15311  			} else {
 15312  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15313  					return err
 15314  				}
 15315  			}
 15316  		case 4:
 15317  			if fieldTypeId == thrift.STRING {
 15318  				if err := p.ReadField4(ctx, tp); err != nil {
 15319  					return err
 15320  				}
 15321  			} else {
 15322  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15323  					return err
 15324  				}
 15325  			}
 15326  		default:
 15327  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15328  				return err
 15329  			}
 15330  		}
 15331  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15332  			return err
 15333  		}
 15334  	}
 15335  	if err := tp.ReadStructEnd(ctx); err != nil {
 15336  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15337  	}
 15338  	return nil
 15339  }
 15340  
 15341  func (p *ZIncrByArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 15342  	if v, err := tp.ReadString(ctx); err != nil {
 15343  		return thrift.PrependError("error reading field 1: ", err)
 15344  	} else {
 15345  		p.Appid = v
 15346  	}
 15347  	return nil
 15348  }
 15349  
 15350  func (p *ZIncrByArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 15351  	if v, err := tp.ReadString(ctx); err != nil {
 15352  		return thrift.PrependError("error reading field 2: ", err)
 15353  	} else {
 15354  		p.Key = v
 15355  	}
 15356  	return nil
 15357  }
 15358  
 15359  func (p *ZIncrByArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 15360  	if v, err := tp.ReadDouble(ctx); err != nil {
 15361  		return thrift.PrependError("error reading field 3: ", err)
 15362  	} else {
 15363  		p.Increment = v
 15364  	}
 15365  	return nil
 15366  }
 15367  
 15368  func (p *ZIncrByArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 15369  	if v, err := tp.ReadString(ctx); err != nil {
 15370  		return thrift.PrependError("error reading field 4: ", err)
 15371  	} else {
 15372  		p.Member = v
 15373  	}
 15374  	return nil
 15375  }
 15376  
 15377  func (p *ZIncrByArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 15378  	if err := tp.WriteStructBegin(ctx, "ZIncrBy_args"); err != nil {
 15379  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15380  	}
 15381  	if p != nil {
 15382  		if err := p.writeField1(ctx, tp); err != nil {
 15383  			return err
 15384  		}
 15385  		if err := p.writeField2(ctx, tp); err != nil {
 15386  			return err
 15387  		}
 15388  		if err := p.writeField3(ctx, tp); err != nil {
 15389  			return err
 15390  		}
 15391  		if err := p.writeField4(ctx, tp); err != nil {
 15392  			return err
 15393  		}
 15394  	}
 15395  	if err := tp.WriteFieldStop(ctx); err != nil {
 15396  		return thrift.PrependError("write field stop error: ", err)
 15397  	}
 15398  	if err := tp.WriteStructEnd(ctx); err != nil {
 15399  		return thrift.PrependError("write struct stop error: ", err)
 15400  	}
 15401  	return nil
 15402  }
 15403  
 15404  func (p *ZIncrByArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 15405  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 15406  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 15407  	}
 15408  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 15409  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 15410  	}
 15411  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15412  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 15413  	}
 15414  	return err
 15415  }
 15416  
 15417  func (p *ZIncrByArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 15418  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 15419  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 15420  	}
 15421  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 15422  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 15423  	}
 15424  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15425  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 15426  	}
 15427  	return err
 15428  }
 15429  
 15430  func (p *ZIncrByArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 15431  	if err := tp.WriteFieldBegin(ctx, "increment", thrift.DOUBLE, 3); err != nil {
 15432  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:increment: ", p), err)
 15433  	}
 15434  	if err := tp.WriteDouble(ctx, float64(p.Increment)); err != nil {
 15435  		return thrift.PrependError(fmt.Sprintf("%T.increment (3) field write error: ", p), err)
 15436  	}
 15437  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15438  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:increment: ", p), err)
 15439  	}
 15440  	return err
 15441  }
 15442  
 15443  func (p *ZIncrByArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 15444  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 4); err != nil {
 15445  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:member: ", p), err)
 15446  	}
 15447  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 15448  		return thrift.PrependError(fmt.Sprintf("%T.member (4) field write error: ", p), err)
 15449  	}
 15450  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15451  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:member: ", p), err)
 15452  	}
 15453  	return err
 15454  }
 15455  
 15456  func (p *ZIncrByArgs) String() string {
 15457  	if p == nil {
 15458  		return "<nil>"
 15459  	}
 15460  	return fmt.Sprintf("ZIncrByArgs(%+v)", *p)
 15461  }
 15462  
 15463  // Attributes:
 15464  //  - Success
 15465  type ZIncrByResult struct {
 15466  	Success *FloatResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 15467  }
 15468  
 15469  func NewZIncrByResult() *ZIncrByResult {
 15470  	return &ZIncrByResult{}
 15471  }
 15472  
 15473  var ZIncrByResult_Success_DEFAULT *FloatResponse
 15474  
 15475  func (p *ZIncrByResult) GetSuccess() *FloatResponse {
 15476  	if !p.IsSetSuccess() {
 15477  		return ZIncrByResult_Success_DEFAULT
 15478  	}
 15479  	return p.Success
 15480  }
 15481  func (p *ZIncrByResult) IsSetSuccess() bool {
 15482  	return p.Success != nil
 15483  }
 15484  
 15485  func (p *ZIncrByResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 15486  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15487  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15488  	}
 15489  
 15490  	for {
 15491  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15492  		if err != nil {
 15493  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15494  		}
 15495  		if fieldTypeId == thrift.STOP {
 15496  			break
 15497  		}
 15498  		switch fieldId {
 15499  		case 0:
 15500  			if fieldTypeId == thrift.STRUCT {
 15501  				if err := p.ReadField0(ctx, tp); err != nil {
 15502  					return err
 15503  				}
 15504  			} else {
 15505  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15506  					return err
 15507  				}
 15508  			}
 15509  		default:
 15510  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15511  				return err
 15512  			}
 15513  		}
 15514  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15515  			return err
 15516  		}
 15517  	}
 15518  	if err := tp.ReadStructEnd(ctx); err != nil {
 15519  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15520  	}
 15521  	return nil
 15522  }
 15523  
 15524  func (p *ZIncrByResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 15525  	p.Success = &FloatResponse{}
 15526  	if err := p.Success.Read(ctx, tp); err != nil {
 15527  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 15528  	}
 15529  	return nil
 15530  }
 15531  
 15532  func (p *ZIncrByResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 15533  	if err := tp.WriteStructBegin(ctx, "ZIncrBy_result"); err != nil {
 15534  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15535  	}
 15536  	if p != nil {
 15537  		if err := p.writeField0(ctx, tp); err != nil {
 15538  			return err
 15539  		}
 15540  	}
 15541  	if err := tp.WriteFieldStop(ctx); err != nil {
 15542  		return thrift.PrependError("write field stop error: ", err)
 15543  	}
 15544  	if err := tp.WriteStructEnd(ctx); err != nil {
 15545  		return thrift.PrependError("write struct stop error: ", err)
 15546  	}
 15547  	return nil
 15548  }
 15549  
 15550  func (p *ZIncrByResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 15551  	if p.IsSetSuccess() {
 15552  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 15553  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 15554  		}
 15555  		if err := p.Success.Write(ctx, tp); err != nil {
 15556  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 15557  		}
 15558  		if err := tp.WriteFieldEnd(ctx); err != nil {
 15559  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 15560  		}
 15561  	}
 15562  	return err
 15563  }
 15564  
 15565  func (p *ZIncrByResult) String() string {
 15566  	if p == nil {
 15567  		return "<nil>"
 15568  	}
 15569  	return fmt.Sprintf("ZIncrByResult(%+v)", *p)
 15570  }
 15571  
 15572  // Attributes:
 15573  //  - Appid
 15574  //  - Key
 15575  //  - Member
 15576  type ZScoreArgs struct {
 15577  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 15578  	Key    string `thrift:"key,2" db:"key" json:"key"`
 15579  	Member string `thrift:"member,3" db:"member" json:"member"`
 15580  }
 15581  
 15582  func NewZScoreArgs() *ZScoreArgs {
 15583  	return &ZScoreArgs{}
 15584  }
 15585  
 15586  func (p *ZScoreArgs) GetAppid() string {
 15587  	return p.Appid
 15588  }
 15589  
 15590  func (p *ZScoreArgs) GetKey() string {
 15591  	return p.Key
 15592  }
 15593  
 15594  func (p *ZScoreArgs) GetMember() string {
 15595  	return p.Member
 15596  }
 15597  func (p *ZScoreArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 15598  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15599  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15600  	}
 15601  
 15602  	for {
 15603  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15604  		if err != nil {
 15605  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15606  		}
 15607  		if fieldTypeId == thrift.STOP {
 15608  			break
 15609  		}
 15610  		switch fieldId {
 15611  		case 1:
 15612  			if fieldTypeId == thrift.STRING {
 15613  				if err := p.ReadField1(ctx, tp); err != nil {
 15614  					return err
 15615  				}
 15616  			} else {
 15617  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15618  					return err
 15619  				}
 15620  			}
 15621  		case 2:
 15622  			if fieldTypeId == thrift.STRING {
 15623  				if err := p.ReadField2(ctx, tp); err != nil {
 15624  					return err
 15625  				}
 15626  			} else {
 15627  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15628  					return err
 15629  				}
 15630  			}
 15631  		case 3:
 15632  			if fieldTypeId == thrift.STRING {
 15633  				if err := p.ReadField3(ctx, tp); err != nil {
 15634  					return err
 15635  				}
 15636  			} else {
 15637  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15638  					return err
 15639  				}
 15640  			}
 15641  		default:
 15642  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15643  				return err
 15644  			}
 15645  		}
 15646  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15647  			return err
 15648  		}
 15649  	}
 15650  	if err := tp.ReadStructEnd(ctx); err != nil {
 15651  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15652  	}
 15653  	return nil
 15654  }
 15655  
 15656  func (p *ZScoreArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 15657  	if v, err := tp.ReadString(ctx); err != nil {
 15658  		return thrift.PrependError("error reading field 1: ", err)
 15659  	} else {
 15660  		p.Appid = v
 15661  	}
 15662  	return nil
 15663  }
 15664  
 15665  func (p *ZScoreArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 15666  	if v, err := tp.ReadString(ctx); err != nil {
 15667  		return thrift.PrependError("error reading field 2: ", err)
 15668  	} else {
 15669  		p.Key = v
 15670  	}
 15671  	return nil
 15672  }
 15673  
 15674  func (p *ZScoreArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 15675  	if v, err := tp.ReadString(ctx); err != nil {
 15676  		return thrift.PrependError("error reading field 3: ", err)
 15677  	} else {
 15678  		p.Member = v
 15679  	}
 15680  	return nil
 15681  }
 15682  
 15683  func (p *ZScoreArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 15684  	if err := tp.WriteStructBegin(ctx, "ZScore_args"); err != nil {
 15685  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15686  	}
 15687  	if p != nil {
 15688  		if err := p.writeField1(ctx, tp); err != nil {
 15689  			return err
 15690  		}
 15691  		if err := p.writeField2(ctx, tp); err != nil {
 15692  			return err
 15693  		}
 15694  		if err := p.writeField3(ctx, tp); err != nil {
 15695  			return err
 15696  		}
 15697  	}
 15698  	if err := tp.WriteFieldStop(ctx); err != nil {
 15699  		return thrift.PrependError("write field stop error: ", err)
 15700  	}
 15701  	if err := tp.WriteStructEnd(ctx); err != nil {
 15702  		return thrift.PrependError("write struct stop error: ", err)
 15703  	}
 15704  	return nil
 15705  }
 15706  
 15707  func (p *ZScoreArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 15708  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 15709  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 15710  	}
 15711  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 15712  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 15713  	}
 15714  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15715  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 15716  	}
 15717  	return err
 15718  }
 15719  
 15720  func (p *ZScoreArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 15721  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 15722  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 15723  	}
 15724  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 15725  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 15726  	}
 15727  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15728  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 15729  	}
 15730  	return err
 15731  }
 15732  
 15733  func (p *ZScoreArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 15734  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 3); err != nil {
 15735  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 15736  	}
 15737  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 15738  		return thrift.PrependError(fmt.Sprintf("%T.member (3) field write error: ", p), err)
 15739  	}
 15740  	if err := tp.WriteFieldEnd(ctx); err != nil {
 15741  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 15742  	}
 15743  	return err
 15744  }
 15745  
 15746  func (p *ZScoreArgs) String() string {
 15747  	if p == nil {
 15748  		return "<nil>"
 15749  	}
 15750  	return fmt.Sprintf("ZScoreArgs(%+v)", *p)
 15751  }
 15752  
 15753  // Attributes:
 15754  //  - Success
 15755  type ZScoreResult struct {
 15756  	Success *FloatResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 15757  }
 15758  
 15759  func NewZScoreResult() *ZScoreResult {
 15760  	return &ZScoreResult{}
 15761  }
 15762  
 15763  var ZScoreResult_Success_DEFAULT *FloatResponse
 15764  
 15765  func (p *ZScoreResult) GetSuccess() *FloatResponse {
 15766  	if !p.IsSetSuccess() {
 15767  		return ZScoreResult_Success_DEFAULT
 15768  	}
 15769  	return p.Success
 15770  }
 15771  func (p *ZScoreResult) IsSetSuccess() bool {
 15772  	return p.Success != nil
 15773  }
 15774  
 15775  func (p *ZScoreResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 15776  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15777  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15778  	}
 15779  
 15780  	for {
 15781  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15782  		if err != nil {
 15783  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15784  		}
 15785  		if fieldTypeId == thrift.STOP {
 15786  			break
 15787  		}
 15788  		switch fieldId {
 15789  		case 0:
 15790  			if fieldTypeId == thrift.STRUCT {
 15791  				if err := p.ReadField0(ctx, tp); err != nil {
 15792  					return err
 15793  				}
 15794  			} else {
 15795  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15796  					return err
 15797  				}
 15798  			}
 15799  		default:
 15800  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15801  				return err
 15802  			}
 15803  		}
 15804  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15805  			return err
 15806  		}
 15807  	}
 15808  	if err := tp.ReadStructEnd(ctx); err != nil {
 15809  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15810  	}
 15811  	return nil
 15812  }
 15813  
 15814  func (p *ZScoreResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 15815  	p.Success = &FloatResponse{}
 15816  	if err := p.Success.Read(ctx, tp); err != nil {
 15817  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 15818  	}
 15819  	return nil
 15820  }
 15821  
 15822  func (p *ZScoreResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 15823  	if err := tp.WriteStructBegin(ctx, "ZScore_result"); err != nil {
 15824  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15825  	}
 15826  	if p != nil {
 15827  		if err := p.writeField0(ctx, tp); err != nil {
 15828  			return err
 15829  		}
 15830  	}
 15831  	if err := tp.WriteFieldStop(ctx); err != nil {
 15832  		return thrift.PrependError("write field stop error: ", err)
 15833  	}
 15834  	if err := tp.WriteStructEnd(ctx); err != nil {
 15835  		return thrift.PrependError("write struct stop error: ", err)
 15836  	}
 15837  	return nil
 15838  }
 15839  
 15840  func (p *ZScoreResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 15841  	if p.IsSetSuccess() {
 15842  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 15843  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 15844  		}
 15845  		if err := p.Success.Write(ctx, tp); err != nil {
 15846  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 15847  		}
 15848  		if err := tp.WriteFieldEnd(ctx); err != nil {
 15849  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 15850  		}
 15851  	}
 15852  	return err
 15853  }
 15854  
 15855  func (p *ZScoreResult) String() string {
 15856  	if p == nil {
 15857  		return "<nil>"
 15858  	}
 15859  	return fmt.Sprintf("ZScoreResult(%+v)", *p)
 15860  }
 15861  
 15862  // Attributes:
 15863  //  - Appid
 15864  //  - Key
 15865  //  - Member
 15866  type SAddArgs struct {
 15867  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 15868  	Key    string `thrift:"key,2" db:"key" json:"key"`
 15869  	Member string `thrift:"member,3" db:"member" json:"member"`
 15870  }
 15871  
 15872  func NewSAddArgs() *SAddArgs {
 15873  	return &SAddArgs{}
 15874  }
 15875  
 15876  func (p *SAddArgs) GetAppid() string {
 15877  	return p.Appid
 15878  }
 15879  
 15880  func (p *SAddArgs) GetKey() string {
 15881  	return p.Key
 15882  }
 15883  
 15884  func (p *SAddArgs) GetMember() string {
 15885  	return p.Member
 15886  }
 15887  func (p *SAddArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 15888  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 15889  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 15890  	}
 15891  
 15892  	for {
 15893  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 15894  		if err != nil {
 15895  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 15896  		}
 15897  		if fieldTypeId == thrift.STOP {
 15898  			break
 15899  		}
 15900  		switch fieldId {
 15901  		case 1:
 15902  			if fieldTypeId == thrift.STRING {
 15903  				if err := p.ReadField1(ctx, tp); err != nil {
 15904  					return err
 15905  				}
 15906  			} else {
 15907  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15908  					return err
 15909  				}
 15910  			}
 15911  		case 2:
 15912  			if fieldTypeId == thrift.STRING {
 15913  				if err := p.ReadField2(ctx, tp); err != nil {
 15914  					return err
 15915  				}
 15916  			} else {
 15917  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15918  					return err
 15919  				}
 15920  			}
 15921  		case 3:
 15922  			if fieldTypeId == thrift.STRING {
 15923  				if err := p.ReadField3(ctx, tp); err != nil {
 15924  					return err
 15925  				}
 15926  			} else {
 15927  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15928  					return err
 15929  				}
 15930  			}
 15931  		default:
 15932  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 15933  				return err
 15934  			}
 15935  		}
 15936  		if err := tp.ReadFieldEnd(ctx); err != nil {
 15937  			return err
 15938  		}
 15939  	}
 15940  	if err := tp.ReadStructEnd(ctx); err != nil {
 15941  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 15942  	}
 15943  	return nil
 15944  }
 15945  
 15946  func (p *SAddArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 15947  	if v, err := tp.ReadString(ctx); err != nil {
 15948  		return thrift.PrependError("error reading field 1: ", err)
 15949  	} else {
 15950  		p.Appid = v
 15951  	}
 15952  	return nil
 15953  }
 15954  
 15955  func (p *SAddArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 15956  	if v, err := tp.ReadString(ctx); err != nil {
 15957  		return thrift.PrependError("error reading field 2: ", err)
 15958  	} else {
 15959  		p.Key = v
 15960  	}
 15961  	return nil
 15962  }
 15963  
 15964  func (p *SAddArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 15965  	if v, err := tp.ReadString(ctx); err != nil {
 15966  		return thrift.PrependError("error reading field 3: ", err)
 15967  	} else {
 15968  		p.Member = v
 15969  	}
 15970  	return nil
 15971  }
 15972  
 15973  func (p *SAddArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 15974  	if err := tp.WriteStructBegin(ctx, "SAdd_args"); err != nil {
 15975  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 15976  	}
 15977  	if p != nil {
 15978  		if err := p.writeField1(ctx, tp); err != nil {
 15979  			return err
 15980  		}
 15981  		if err := p.writeField2(ctx, tp); err != nil {
 15982  			return err
 15983  		}
 15984  		if err := p.writeField3(ctx, tp); err != nil {
 15985  			return err
 15986  		}
 15987  	}
 15988  	if err := tp.WriteFieldStop(ctx); err != nil {
 15989  		return thrift.PrependError("write field stop error: ", err)
 15990  	}
 15991  	if err := tp.WriteStructEnd(ctx); err != nil {
 15992  		return thrift.PrependError("write struct stop error: ", err)
 15993  	}
 15994  	return nil
 15995  }
 15996  
 15997  func (p *SAddArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 15998  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 15999  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 16000  	}
 16001  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 16002  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 16003  	}
 16004  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16005  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 16006  	}
 16007  	return err
 16008  }
 16009  
 16010  func (p *SAddArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 16011  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 16012  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 16013  	}
 16014  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 16015  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 16016  	}
 16017  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16018  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 16019  	}
 16020  	return err
 16021  }
 16022  
 16023  func (p *SAddArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 16024  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 3); err != nil {
 16025  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 16026  	}
 16027  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 16028  		return thrift.PrependError(fmt.Sprintf("%T.member (3) field write error: ", p), err)
 16029  	}
 16030  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16031  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 16032  	}
 16033  	return err
 16034  }
 16035  
 16036  func (p *SAddArgs) String() string {
 16037  	if p == nil {
 16038  		return "<nil>"
 16039  	}
 16040  	return fmt.Sprintf("SAddArgs(%+v)", *p)
 16041  }
 16042  
 16043  // Attributes:
 16044  //  - Success
 16045  type SAddResult struct {
 16046  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 16047  }
 16048  
 16049  func NewSAddResult() *SAddResult {
 16050  	return &SAddResult{}
 16051  }
 16052  
 16053  var SAddResult_Success_DEFAULT *IntResponse
 16054  
 16055  func (p *SAddResult) GetSuccess() *IntResponse {
 16056  	if !p.IsSetSuccess() {
 16057  		return SAddResult_Success_DEFAULT
 16058  	}
 16059  	return p.Success
 16060  }
 16061  func (p *SAddResult) IsSetSuccess() bool {
 16062  	return p.Success != nil
 16063  }
 16064  
 16065  func (p *SAddResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 16066  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16067  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16068  	}
 16069  
 16070  	for {
 16071  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16072  		if err != nil {
 16073  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16074  		}
 16075  		if fieldTypeId == thrift.STOP {
 16076  			break
 16077  		}
 16078  		switch fieldId {
 16079  		case 0:
 16080  			if fieldTypeId == thrift.STRUCT {
 16081  				if err := p.ReadField0(ctx, tp); err != nil {
 16082  					return err
 16083  				}
 16084  			} else {
 16085  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16086  					return err
 16087  				}
 16088  			}
 16089  		default:
 16090  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16091  				return err
 16092  			}
 16093  		}
 16094  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16095  			return err
 16096  		}
 16097  	}
 16098  	if err := tp.ReadStructEnd(ctx); err != nil {
 16099  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16100  	}
 16101  	return nil
 16102  }
 16103  
 16104  func (p *SAddResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 16105  	p.Success = &IntResponse{}
 16106  	if err := p.Success.Read(ctx, tp); err != nil {
 16107  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 16108  	}
 16109  	return nil
 16110  }
 16111  
 16112  func (p *SAddResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 16113  	if err := tp.WriteStructBegin(ctx, "SAdd_result"); err != nil {
 16114  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16115  	}
 16116  	if p != nil {
 16117  		if err := p.writeField0(ctx, tp); err != nil {
 16118  			return err
 16119  		}
 16120  	}
 16121  	if err := tp.WriteFieldStop(ctx); err != nil {
 16122  		return thrift.PrependError("write field stop error: ", err)
 16123  	}
 16124  	if err := tp.WriteStructEnd(ctx); err != nil {
 16125  		return thrift.PrependError("write struct stop error: ", err)
 16126  	}
 16127  	return nil
 16128  }
 16129  
 16130  func (p *SAddResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 16131  	if p.IsSetSuccess() {
 16132  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 16133  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 16134  		}
 16135  		if err := p.Success.Write(ctx, tp); err != nil {
 16136  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 16137  		}
 16138  		if err := tp.WriteFieldEnd(ctx); err != nil {
 16139  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 16140  		}
 16141  	}
 16142  	return err
 16143  }
 16144  
 16145  func (p *SAddResult) String() string {
 16146  	if p == nil {
 16147  		return "<nil>"
 16148  	}
 16149  	return fmt.Sprintf("SAddResult(%+v)", *p)
 16150  }
 16151  
 16152  // Attributes:
 16153  //  - Appid
 16154  //  - Key
 16155  //  - Members
 16156  type MsAddArgs struct {
 16157  	Appid   string   `thrift:"appid,1" db:"appid" json:"appid"`
 16158  	Key     string   `thrift:"key,2" db:"key" json:"key"`
 16159  	Members []string `thrift:"members,3" db:"members" json:"members"`
 16160  }
 16161  
 16162  func NewMSAddArgs() *MsAddArgs {
 16163  	return &MsAddArgs{}
 16164  }
 16165  
 16166  func (p *MsAddArgs) GetAppid() string {
 16167  	return p.Appid
 16168  }
 16169  
 16170  func (p *MsAddArgs) GetKey() string {
 16171  	return p.Key
 16172  }
 16173  
 16174  func (p *MsAddArgs) GetMembers() []string {
 16175  	return p.Members
 16176  }
 16177  func (p *MsAddArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 16178  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16179  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16180  	}
 16181  
 16182  	for {
 16183  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16184  		if err != nil {
 16185  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16186  		}
 16187  		if fieldTypeId == thrift.STOP {
 16188  			break
 16189  		}
 16190  		switch fieldId {
 16191  		case 1:
 16192  			if fieldTypeId == thrift.STRING {
 16193  				if err := p.ReadField1(ctx, tp); err != nil {
 16194  					return err
 16195  				}
 16196  			} else {
 16197  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16198  					return err
 16199  				}
 16200  			}
 16201  		case 2:
 16202  			if fieldTypeId == thrift.STRING {
 16203  				if err := p.ReadField2(ctx, tp); err != nil {
 16204  					return err
 16205  				}
 16206  			} else {
 16207  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16208  					return err
 16209  				}
 16210  			}
 16211  		case 3:
 16212  			if fieldTypeId == thrift.LIST {
 16213  				if err := p.ReadField3(ctx, tp); err != nil {
 16214  					return err
 16215  				}
 16216  			} else {
 16217  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16218  					return err
 16219  				}
 16220  			}
 16221  		default:
 16222  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16223  				return err
 16224  			}
 16225  		}
 16226  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16227  			return err
 16228  		}
 16229  	}
 16230  	if err := tp.ReadStructEnd(ctx); err != nil {
 16231  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16232  	}
 16233  	return nil
 16234  }
 16235  
 16236  func (p *MsAddArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 16237  	if v, err := tp.ReadString(ctx); err != nil {
 16238  		return thrift.PrependError("error reading field 1: ", err)
 16239  	} else {
 16240  		p.Appid = v
 16241  	}
 16242  	return nil
 16243  }
 16244  
 16245  func (p *MsAddArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 16246  	if v, err := tp.ReadString(ctx); err != nil {
 16247  		return thrift.PrependError("error reading field 2: ", err)
 16248  	} else {
 16249  		p.Key = v
 16250  	}
 16251  	return nil
 16252  }
 16253  
 16254  func (p *MsAddArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 16255  	_, size, err := tp.ReadListBegin(ctx)
 16256  	if err != nil {
 16257  		return thrift.PrependError("error reading list begin: ", err)
 16258  	}
 16259  	tSlice := make([]string, 0, size)
 16260  	p.Members = tSlice
 16261  	for i := 0; i < size; i++ {
 16262  		var _elem195 string
 16263  		if v, err := tp.ReadString(ctx); err != nil {
 16264  			return thrift.PrependError("error reading field 0: ", err)
 16265  		} else {
 16266  			_elem195 = v
 16267  		}
 16268  		p.Members = append(p.Members, _elem195)
 16269  	}
 16270  	if err := tp.ReadListEnd(ctx); err != nil {
 16271  		return thrift.PrependError("error reading list end: ", err)
 16272  	}
 16273  	return nil
 16274  }
 16275  
 16276  func (p *MsAddArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 16277  	if err := tp.WriteStructBegin(ctx, "MSAdd_args"); err != nil {
 16278  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16279  	}
 16280  	if p != nil {
 16281  		if err := p.writeField1(ctx, tp); err != nil {
 16282  			return err
 16283  		}
 16284  		if err := p.writeField2(ctx, tp); err != nil {
 16285  			return err
 16286  		}
 16287  		if err := p.writeField3(ctx, tp); err != nil {
 16288  			return err
 16289  		}
 16290  	}
 16291  	if err := tp.WriteFieldStop(ctx); err != nil {
 16292  		return thrift.PrependError("write field stop error: ", err)
 16293  	}
 16294  	if err := tp.WriteStructEnd(ctx); err != nil {
 16295  		return thrift.PrependError("write struct stop error: ", err)
 16296  	}
 16297  	return nil
 16298  }
 16299  
 16300  func (p *MsAddArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 16301  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 16302  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 16303  	}
 16304  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 16305  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 16306  	}
 16307  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16308  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 16309  	}
 16310  	return err
 16311  }
 16312  
 16313  func (p *MsAddArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 16314  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 16315  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 16316  	}
 16317  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 16318  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 16319  	}
 16320  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16321  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 16322  	}
 16323  	return err
 16324  }
 16325  
 16326  func (p *MsAddArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 16327  	if err := tp.WriteFieldBegin(ctx, "members", thrift.LIST, 3); err != nil {
 16328  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:members: ", p), err)
 16329  	}
 16330  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Members)); err != nil {
 16331  		return thrift.PrependError("error writing list begin: ", err)
 16332  	}
 16333  	for _, v := range p.Members {
 16334  		if err := tp.WriteString(ctx, string(v)); err != nil {
 16335  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 16336  		}
 16337  	}
 16338  	if err := tp.WriteListEnd(ctx); err != nil {
 16339  		return thrift.PrependError("error writing list end: ", err)
 16340  	}
 16341  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16342  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:members: ", p), err)
 16343  	}
 16344  	return err
 16345  }
 16346  
 16347  func (p *MsAddArgs) String() string {
 16348  	if p == nil {
 16349  		return "<nil>"
 16350  	}
 16351  	return fmt.Sprintf("MsAddArgs(%+v)", *p)
 16352  }
 16353  
 16354  // Attributes:
 16355  //  - Success
 16356  type MsAddResult struct {
 16357  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 16358  }
 16359  
 16360  func NewMSAddResult() *MsAddResult {
 16361  	return &MsAddResult{}
 16362  }
 16363  
 16364  var MSAddResult_Success_DEFAULT *IntResponse
 16365  
 16366  func (p *MsAddResult) GetSuccess() *IntResponse {
 16367  	if !p.IsSetSuccess() {
 16368  		return MSAddResult_Success_DEFAULT
 16369  	}
 16370  	return p.Success
 16371  }
 16372  func (p *MsAddResult) IsSetSuccess() bool {
 16373  	return p.Success != nil
 16374  }
 16375  
 16376  func (p *MsAddResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 16377  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16378  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16379  	}
 16380  
 16381  	for {
 16382  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16383  		if err != nil {
 16384  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16385  		}
 16386  		if fieldTypeId == thrift.STOP {
 16387  			break
 16388  		}
 16389  		switch fieldId {
 16390  		case 0:
 16391  			if fieldTypeId == thrift.STRUCT {
 16392  				if err := p.ReadField0(ctx, tp); err != nil {
 16393  					return err
 16394  				}
 16395  			} else {
 16396  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16397  					return err
 16398  				}
 16399  			}
 16400  		default:
 16401  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16402  				return err
 16403  			}
 16404  		}
 16405  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16406  			return err
 16407  		}
 16408  	}
 16409  	if err := tp.ReadStructEnd(ctx); err != nil {
 16410  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16411  	}
 16412  	return nil
 16413  }
 16414  
 16415  func (p *MsAddResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 16416  	p.Success = &IntResponse{}
 16417  	if err := p.Success.Read(ctx, tp); err != nil {
 16418  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 16419  	}
 16420  	return nil
 16421  }
 16422  
 16423  func (p *MsAddResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 16424  	if err := tp.WriteStructBegin(ctx, "MSAdd_result"); err != nil {
 16425  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16426  	}
 16427  	if p != nil {
 16428  		if err := p.writeField0(ctx, tp); err != nil {
 16429  			return err
 16430  		}
 16431  	}
 16432  	if err := tp.WriteFieldStop(ctx); err != nil {
 16433  		return thrift.PrependError("write field stop error: ", err)
 16434  	}
 16435  	if err := tp.WriteStructEnd(ctx); err != nil {
 16436  		return thrift.PrependError("write struct stop error: ", err)
 16437  	}
 16438  	return nil
 16439  }
 16440  
 16441  func (p *MsAddResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 16442  	if p.IsSetSuccess() {
 16443  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 16444  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 16445  		}
 16446  		if err := p.Success.Write(ctx, tp); err != nil {
 16447  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 16448  		}
 16449  		if err := tp.WriteFieldEnd(ctx); err != nil {
 16450  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 16451  		}
 16452  	}
 16453  	return err
 16454  }
 16455  
 16456  func (p *MsAddResult) String() string {
 16457  	if p == nil {
 16458  		return "<nil>"
 16459  	}
 16460  	return fmt.Sprintf("MsAddResult(%+v)", *p)
 16461  }
 16462  
 16463  // Attributes:
 16464  //  - Appid
 16465  //  - Key
 16466  type SCardArgs struct {
 16467  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 16468  	Key   string `thrift:"key,2" db:"key" json:"key"`
 16469  }
 16470  
 16471  func NewSCardArgs() *SCardArgs {
 16472  	return &SCardArgs{}
 16473  }
 16474  
 16475  func (p *SCardArgs) GetAppid() string {
 16476  	return p.Appid
 16477  }
 16478  
 16479  func (p *SCardArgs) GetKey() string {
 16480  	return p.Key
 16481  }
 16482  func (p *SCardArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 16483  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16484  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16485  	}
 16486  
 16487  	for {
 16488  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16489  		if err != nil {
 16490  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16491  		}
 16492  		if fieldTypeId == thrift.STOP {
 16493  			break
 16494  		}
 16495  		switch fieldId {
 16496  		case 1:
 16497  			if fieldTypeId == thrift.STRING {
 16498  				if err := p.ReadField1(ctx, tp); err != nil {
 16499  					return err
 16500  				}
 16501  			} else {
 16502  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16503  					return err
 16504  				}
 16505  			}
 16506  		case 2:
 16507  			if fieldTypeId == thrift.STRING {
 16508  				if err := p.ReadField2(ctx, tp); err != nil {
 16509  					return err
 16510  				}
 16511  			} else {
 16512  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16513  					return err
 16514  				}
 16515  			}
 16516  		default:
 16517  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16518  				return err
 16519  			}
 16520  		}
 16521  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16522  			return err
 16523  		}
 16524  	}
 16525  	if err := tp.ReadStructEnd(ctx); err != nil {
 16526  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16527  	}
 16528  	return nil
 16529  }
 16530  
 16531  func (p *SCardArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 16532  	if v, err := tp.ReadString(ctx); err != nil {
 16533  		return thrift.PrependError("error reading field 1: ", err)
 16534  	} else {
 16535  		p.Appid = v
 16536  	}
 16537  	return nil
 16538  }
 16539  
 16540  func (p *SCardArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 16541  	if v, err := tp.ReadString(ctx); err != nil {
 16542  		return thrift.PrependError("error reading field 2: ", err)
 16543  	} else {
 16544  		p.Key = v
 16545  	}
 16546  	return nil
 16547  }
 16548  
 16549  func (p *SCardArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 16550  	if err := tp.WriteStructBegin(ctx, "SCard_args"); err != nil {
 16551  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16552  	}
 16553  	if p != nil {
 16554  		if err := p.writeField1(ctx, tp); err != nil {
 16555  			return err
 16556  		}
 16557  		if err := p.writeField2(ctx, tp); err != nil {
 16558  			return err
 16559  		}
 16560  	}
 16561  	if err := tp.WriteFieldStop(ctx); err != nil {
 16562  		return thrift.PrependError("write field stop error: ", err)
 16563  	}
 16564  	if err := tp.WriteStructEnd(ctx); err != nil {
 16565  		return thrift.PrependError("write struct stop error: ", err)
 16566  	}
 16567  	return nil
 16568  }
 16569  
 16570  func (p *SCardArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 16571  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 16572  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 16573  	}
 16574  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 16575  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 16576  	}
 16577  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16578  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 16579  	}
 16580  	return err
 16581  }
 16582  
 16583  func (p *SCardArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 16584  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 16585  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 16586  	}
 16587  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 16588  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 16589  	}
 16590  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16591  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 16592  	}
 16593  	return err
 16594  }
 16595  
 16596  func (p *SCardArgs) String() string {
 16597  	if p == nil {
 16598  		return "<nil>"
 16599  	}
 16600  	return fmt.Sprintf("SCardArgs(%+v)", *p)
 16601  }
 16602  
 16603  // Attributes:
 16604  //  - Success
 16605  type SCardResult struct {
 16606  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 16607  }
 16608  
 16609  func NewSCardResult() *SCardResult {
 16610  	return &SCardResult{}
 16611  }
 16612  
 16613  var SCardResult_Success_DEFAULT *IntResponse
 16614  
 16615  func (p *SCardResult) GetSuccess() *IntResponse {
 16616  	if !p.IsSetSuccess() {
 16617  		return SCardResult_Success_DEFAULT
 16618  	}
 16619  	return p.Success
 16620  }
 16621  func (p *SCardResult) IsSetSuccess() bool {
 16622  	return p.Success != nil
 16623  }
 16624  
 16625  func (p *SCardResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 16626  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16627  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16628  	}
 16629  
 16630  	for {
 16631  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16632  		if err != nil {
 16633  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16634  		}
 16635  		if fieldTypeId == thrift.STOP {
 16636  			break
 16637  		}
 16638  		switch fieldId {
 16639  		case 0:
 16640  			if fieldTypeId == thrift.STRUCT {
 16641  				if err := p.ReadField0(ctx, tp); err != nil {
 16642  					return err
 16643  				}
 16644  			} else {
 16645  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16646  					return err
 16647  				}
 16648  			}
 16649  		default:
 16650  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16651  				return err
 16652  			}
 16653  		}
 16654  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16655  			return err
 16656  		}
 16657  	}
 16658  	if err := tp.ReadStructEnd(ctx); err != nil {
 16659  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16660  	}
 16661  	return nil
 16662  }
 16663  
 16664  func (p *SCardResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 16665  	p.Success = &IntResponse{}
 16666  	if err := p.Success.Read(ctx, tp); err != nil {
 16667  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 16668  	}
 16669  	return nil
 16670  }
 16671  
 16672  func (p *SCardResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 16673  	if err := tp.WriteStructBegin(ctx, "SCard_result"); err != nil {
 16674  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16675  	}
 16676  	if p != nil {
 16677  		if err := p.writeField0(ctx, tp); err != nil {
 16678  			return err
 16679  		}
 16680  	}
 16681  	if err := tp.WriteFieldStop(ctx); err != nil {
 16682  		return thrift.PrependError("write field stop error: ", err)
 16683  	}
 16684  	if err := tp.WriteStructEnd(ctx); err != nil {
 16685  		return thrift.PrependError("write struct stop error: ", err)
 16686  	}
 16687  	return nil
 16688  }
 16689  
 16690  func (p *SCardResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 16691  	if p.IsSetSuccess() {
 16692  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 16693  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 16694  		}
 16695  		if err := p.Success.Write(ctx, tp); err != nil {
 16696  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 16697  		}
 16698  		if err := tp.WriteFieldEnd(ctx); err != nil {
 16699  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 16700  		}
 16701  	}
 16702  	return err
 16703  }
 16704  
 16705  func (p *SCardResult) String() string {
 16706  	if p == nil {
 16707  		return "<nil>"
 16708  	}
 16709  	return fmt.Sprintf("SCardResult(%+v)", *p)
 16710  }
 16711  
 16712  // Attributes:
 16713  //  - Appid
 16714  //  - Key
 16715  //  - Member
 16716  type SIsMemberArgs struct {
 16717  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 16718  	Key    string `thrift:"key,2" db:"key" json:"key"`
 16719  	Member string `thrift:"member,3" db:"member" json:"member"`
 16720  }
 16721  
 16722  func NewSIsMemberArgs() *SIsMemberArgs {
 16723  	return &SIsMemberArgs{}
 16724  }
 16725  
 16726  func (p *SIsMemberArgs) GetAppid() string {
 16727  	return p.Appid
 16728  }
 16729  
 16730  func (p *SIsMemberArgs) GetKey() string {
 16731  	return p.Key
 16732  }
 16733  
 16734  func (p *SIsMemberArgs) GetMember() string {
 16735  	return p.Member
 16736  }
 16737  func (p *SIsMemberArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 16738  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16739  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16740  	}
 16741  
 16742  	for {
 16743  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16744  		if err != nil {
 16745  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16746  		}
 16747  		if fieldTypeId == thrift.STOP {
 16748  			break
 16749  		}
 16750  		switch fieldId {
 16751  		case 1:
 16752  			if fieldTypeId == thrift.STRING {
 16753  				if err := p.ReadField1(ctx, tp); err != nil {
 16754  					return err
 16755  				}
 16756  			} else {
 16757  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16758  					return err
 16759  				}
 16760  			}
 16761  		case 2:
 16762  			if fieldTypeId == thrift.STRING {
 16763  				if err := p.ReadField2(ctx, tp); err != nil {
 16764  					return err
 16765  				}
 16766  			} else {
 16767  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16768  					return err
 16769  				}
 16770  			}
 16771  		case 3:
 16772  			if fieldTypeId == thrift.STRING {
 16773  				if err := p.ReadField3(ctx, tp); err != nil {
 16774  					return err
 16775  				}
 16776  			} else {
 16777  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16778  					return err
 16779  				}
 16780  			}
 16781  		default:
 16782  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16783  				return err
 16784  			}
 16785  		}
 16786  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16787  			return err
 16788  		}
 16789  	}
 16790  	if err := tp.ReadStructEnd(ctx); err != nil {
 16791  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16792  	}
 16793  	return nil
 16794  }
 16795  
 16796  func (p *SIsMemberArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 16797  	if v, err := tp.ReadString(ctx); err != nil {
 16798  		return thrift.PrependError("error reading field 1: ", err)
 16799  	} else {
 16800  		p.Appid = v
 16801  	}
 16802  	return nil
 16803  }
 16804  
 16805  func (p *SIsMemberArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 16806  	if v, err := tp.ReadString(ctx); err != nil {
 16807  		return thrift.PrependError("error reading field 2: ", err)
 16808  	} else {
 16809  		p.Key = v
 16810  	}
 16811  	return nil
 16812  }
 16813  
 16814  func (p *SIsMemberArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 16815  	if v, err := tp.ReadString(ctx); err != nil {
 16816  		return thrift.PrependError("error reading field 3: ", err)
 16817  	} else {
 16818  		p.Member = v
 16819  	}
 16820  	return nil
 16821  }
 16822  
 16823  func (p *SIsMemberArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 16824  	if err := tp.WriteStructBegin(ctx, "SIsMember_args"); err != nil {
 16825  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16826  	}
 16827  	if p != nil {
 16828  		if err := p.writeField1(ctx, tp); err != nil {
 16829  			return err
 16830  		}
 16831  		if err := p.writeField2(ctx, tp); err != nil {
 16832  			return err
 16833  		}
 16834  		if err := p.writeField3(ctx, tp); err != nil {
 16835  			return err
 16836  		}
 16837  	}
 16838  	if err := tp.WriteFieldStop(ctx); err != nil {
 16839  		return thrift.PrependError("write field stop error: ", err)
 16840  	}
 16841  	if err := tp.WriteStructEnd(ctx); err != nil {
 16842  		return thrift.PrependError("write struct stop error: ", err)
 16843  	}
 16844  	return nil
 16845  }
 16846  
 16847  func (p *SIsMemberArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 16848  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 16849  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 16850  	}
 16851  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 16852  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 16853  	}
 16854  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16855  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 16856  	}
 16857  	return err
 16858  }
 16859  
 16860  func (p *SIsMemberArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 16861  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 16862  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 16863  	}
 16864  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 16865  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 16866  	}
 16867  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16868  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 16869  	}
 16870  	return err
 16871  }
 16872  
 16873  func (p *SIsMemberArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 16874  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 3); err != nil {
 16875  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 16876  	}
 16877  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 16878  		return thrift.PrependError(fmt.Sprintf("%T.member (3) field write error: ", p), err)
 16879  	}
 16880  	if err := tp.WriteFieldEnd(ctx); err != nil {
 16881  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 16882  	}
 16883  	return err
 16884  }
 16885  
 16886  func (p *SIsMemberArgs) String() string {
 16887  	if p == nil {
 16888  		return "<nil>"
 16889  	}
 16890  	return fmt.Sprintf("SIsMemberArgs(%+v)", *p)
 16891  }
 16892  
 16893  // Attributes:
 16894  //  - Success
 16895  type SIsMemberResult struct {
 16896  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 16897  }
 16898  
 16899  func NewSIsMemberResult() *SIsMemberResult {
 16900  	return &SIsMemberResult{}
 16901  }
 16902  
 16903  var SIsMemberResult_Success_DEFAULT *Response
 16904  
 16905  func (p *SIsMemberResult) GetSuccess() *Response {
 16906  	if !p.IsSetSuccess() {
 16907  		return SIsMemberResult_Success_DEFAULT
 16908  	}
 16909  	return p.Success
 16910  }
 16911  func (p *SIsMemberResult) IsSetSuccess() bool {
 16912  	return p.Success != nil
 16913  }
 16914  
 16915  func (p *SIsMemberResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 16916  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 16917  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 16918  	}
 16919  
 16920  	for {
 16921  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 16922  		if err != nil {
 16923  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 16924  		}
 16925  		if fieldTypeId == thrift.STOP {
 16926  			break
 16927  		}
 16928  		switch fieldId {
 16929  		case 0:
 16930  			if fieldTypeId == thrift.STRUCT {
 16931  				if err := p.ReadField0(ctx, tp); err != nil {
 16932  					return err
 16933  				}
 16934  			} else {
 16935  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16936  					return err
 16937  				}
 16938  			}
 16939  		default:
 16940  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 16941  				return err
 16942  			}
 16943  		}
 16944  		if err := tp.ReadFieldEnd(ctx); err != nil {
 16945  			return err
 16946  		}
 16947  	}
 16948  	if err := tp.ReadStructEnd(ctx); err != nil {
 16949  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 16950  	}
 16951  	return nil
 16952  }
 16953  
 16954  func (p *SIsMemberResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 16955  	p.Success = &Response{}
 16956  	if err := p.Success.Read(ctx, tp); err != nil {
 16957  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 16958  	}
 16959  	return nil
 16960  }
 16961  
 16962  func (p *SIsMemberResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 16963  	if err := tp.WriteStructBegin(ctx, "SIsMember_result"); err != nil {
 16964  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 16965  	}
 16966  	if p != nil {
 16967  		if err := p.writeField0(ctx, tp); err != nil {
 16968  			return err
 16969  		}
 16970  	}
 16971  	if err := tp.WriteFieldStop(ctx); err != nil {
 16972  		return thrift.PrependError("write field stop error: ", err)
 16973  	}
 16974  	if err := tp.WriteStructEnd(ctx); err != nil {
 16975  		return thrift.PrependError("write struct stop error: ", err)
 16976  	}
 16977  	return nil
 16978  }
 16979  
 16980  func (p *SIsMemberResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 16981  	if p.IsSetSuccess() {
 16982  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 16983  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 16984  		}
 16985  		if err := p.Success.Write(ctx, tp); err != nil {
 16986  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 16987  		}
 16988  		if err := tp.WriteFieldEnd(ctx); err != nil {
 16989  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 16990  		}
 16991  	}
 16992  	return err
 16993  }
 16994  
 16995  func (p *SIsMemberResult) String() string {
 16996  	if p == nil {
 16997  		return "<nil>"
 16998  	}
 16999  	return fmt.Sprintf("SIsMemberResult(%+v)", *p)
 17000  }
 17001  
 17002  // Attributes:
 17003  //  - Appid
 17004  //  - Key
 17005  type SMembersArgs struct {
 17006  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 17007  	Key   string `thrift:"key,2" db:"key" json:"key"`
 17008  }
 17009  
 17010  func NewSMembersArgs() *SMembersArgs {
 17011  	return &SMembersArgs{}
 17012  }
 17013  
 17014  func (p *SMembersArgs) GetAppid() string {
 17015  	return p.Appid
 17016  }
 17017  
 17018  func (p *SMembersArgs) GetKey() string {
 17019  	return p.Key
 17020  }
 17021  func (p *SMembersArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 17022  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17023  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17024  	}
 17025  
 17026  	for {
 17027  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17028  		if err != nil {
 17029  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17030  		}
 17031  		if fieldTypeId == thrift.STOP {
 17032  			break
 17033  		}
 17034  		switch fieldId {
 17035  		case 1:
 17036  			if fieldTypeId == thrift.STRING {
 17037  				if err := p.ReadField1(ctx, tp); err != nil {
 17038  					return err
 17039  				}
 17040  			} else {
 17041  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17042  					return err
 17043  				}
 17044  			}
 17045  		case 2:
 17046  			if fieldTypeId == thrift.STRING {
 17047  				if err := p.ReadField2(ctx, tp); err != nil {
 17048  					return err
 17049  				}
 17050  			} else {
 17051  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17052  					return err
 17053  				}
 17054  			}
 17055  		default:
 17056  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17057  				return err
 17058  			}
 17059  		}
 17060  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17061  			return err
 17062  		}
 17063  	}
 17064  	if err := tp.ReadStructEnd(ctx); err != nil {
 17065  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17066  	}
 17067  	return nil
 17068  }
 17069  
 17070  func (p *SMembersArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 17071  	if v, err := tp.ReadString(ctx); err != nil {
 17072  		return thrift.PrependError("error reading field 1: ", err)
 17073  	} else {
 17074  		p.Appid = v
 17075  	}
 17076  	return nil
 17077  }
 17078  
 17079  func (p *SMembersArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 17080  	if v, err := tp.ReadString(ctx); err != nil {
 17081  		return thrift.PrependError("error reading field 2: ", err)
 17082  	} else {
 17083  		p.Key = v
 17084  	}
 17085  	return nil
 17086  }
 17087  
 17088  func (p *SMembersArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 17089  	if err := tp.WriteStructBegin(ctx, "SMembers_args"); err != nil {
 17090  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17091  	}
 17092  	if p != nil {
 17093  		if err := p.writeField1(ctx, tp); err != nil {
 17094  			return err
 17095  		}
 17096  		if err := p.writeField2(ctx, tp); err != nil {
 17097  			return err
 17098  		}
 17099  	}
 17100  	if err := tp.WriteFieldStop(ctx); err != nil {
 17101  		return thrift.PrependError("write field stop error: ", err)
 17102  	}
 17103  	if err := tp.WriteStructEnd(ctx); err != nil {
 17104  		return thrift.PrependError("write struct stop error: ", err)
 17105  	}
 17106  	return nil
 17107  }
 17108  
 17109  func (p *SMembersArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 17110  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 17111  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 17112  	}
 17113  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 17114  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 17115  	}
 17116  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17117  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 17118  	}
 17119  	return err
 17120  }
 17121  
 17122  func (p *SMembersArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 17123  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 17124  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 17125  	}
 17126  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 17127  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 17128  	}
 17129  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17130  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 17131  	}
 17132  	return err
 17133  }
 17134  
 17135  func (p *SMembersArgs) String() string {
 17136  	if p == nil {
 17137  		return "<nil>"
 17138  	}
 17139  	return fmt.Sprintf("SMembersArgs(%+v)", *p)
 17140  }
 17141  
 17142  // Attributes:
 17143  //  - Success
 17144  type SMembersResult struct {
 17145  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 17146  }
 17147  
 17148  func NewSMembersResult() *SMembersResult {
 17149  	return &SMembersResult{}
 17150  }
 17151  
 17152  var SMembersResult_Success_DEFAULT *LResponse
 17153  
 17154  func (p *SMembersResult) GetSuccess() *LResponse {
 17155  	if !p.IsSetSuccess() {
 17156  		return SMembersResult_Success_DEFAULT
 17157  	}
 17158  	return p.Success
 17159  }
 17160  func (p *SMembersResult) IsSetSuccess() bool {
 17161  	return p.Success != nil
 17162  }
 17163  
 17164  func (p *SMembersResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 17165  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17166  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17167  	}
 17168  
 17169  	for {
 17170  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17171  		if err != nil {
 17172  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17173  		}
 17174  		if fieldTypeId == thrift.STOP {
 17175  			break
 17176  		}
 17177  		switch fieldId {
 17178  		case 0:
 17179  			if fieldTypeId == thrift.STRUCT {
 17180  				if err := p.ReadField0(ctx, tp); err != nil {
 17181  					return err
 17182  				}
 17183  			} else {
 17184  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17185  					return err
 17186  				}
 17187  			}
 17188  		default:
 17189  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17190  				return err
 17191  			}
 17192  		}
 17193  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17194  			return err
 17195  		}
 17196  	}
 17197  	if err := tp.ReadStructEnd(ctx); err != nil {
 17198  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17199  	}
 17200  	return nil
 17201  }
 17202  
 17203  func (p *SMembersResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 17204  	p.Success = &LResponse{}
 17205  	if err := p.Success.Read(ctx, tp); err != nil {
 17206  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 17207  	}
 17208  	return nil
 17209  }
 17210  
 17211  func (p *SMembersResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 17212  	if err := tp.WriteStructBegin(ctx, "SMembers_result"); err != nil {
 17213  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17214  	}
 17215  	if p != nil {
 17216  		if err := p.writeField0(ctx, tp); err != nil {
 17217  			return err
 17218  		}
 17219  	}
 17220  	if err := tp.WriteFieldStop(ctx); err != nil {
 17221  		return thrift.PrependError("write field stop error: ", err)
 17222  	}
 17223  	if err := tp.WriteStructEnd(ctx); err != nil {
 17224  		return thrift.PrependError("write struct stop error: ", err)
 17225  	}
 17226  	return nil
 17227  }
 17228  
 17229  func (p *SMembersResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 17230  	if p.IsSetSuccess() {
 17231  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 17232  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 17233  		}
 17234  		if err := p.Success.Write(ctx, tp); err != nil {
 17235  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 17236  		}
 17237  		if err := tp.WriteFieldEnd(ctx); err != nil {
 17238  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 17239  		}
 17240  	}
 17241  	return err
 17242  }
 17243  
 17244  func (p *SMembersResult) String() string {
 17245  	if p == nil {
 17246  		return "<nil>"
 17247  	}
 17248  	return fmt.Sprintf("SMembersResult(%+v)", *p)
 17249  }
 17250  
 17251  // Attributes:
 17252  //  - Appid
 17253  //  - Key
 17254  type SRandMemberArgs struct {
 17255  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 17256  	Key   string `thrift:"key,2" db:"key" json:"key"`
 17257  }
 17258  
 17259  func NewSRandMemberArgs() *SRandMemberArgs {
 17260  	return &SRandMemberArgs{}
 17261  }
 17262  
 17263  func (p *SRandMemberArgs) GetAppid() string {
 17264  	return p.Appid
 17265  }
 17266  
 17267  func (p *SRandMemberArgs) GetKey() string {
 17268  	return p.Key
 17269  }
 17270  func (p *SRandMemberArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 17271  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17272  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17273  	}
 17274  
 17275  	for {
 17276  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17277  		if err != nil {
 17278  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17279  		}
 17280  		if fieldTypeId == thrift.STOP {
 17281  			break
 17282  		}
 17283  		switch fieldId {
 17284  		case 1:
 17285  			if fieldTypeId == thrift.STRING {
 17286  				if err := p.ReadField1(ctx, tp); err != nil {
 17287  					return err
 17288  				}
 17289  			} else {
 17290  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17291  					return err
 17292  				}
 17293  			}
 17294  		case 2:
 17295  			if fieldTypeId == thrift.STRING {
 17296  				if err := p.ReadField2(ctx, tp); err != nil {
 17297  					return err
 17298  				}
 17299  			} else {
 17300  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17301  					return err
 17302  				}
 17303  			}
 17304  		default:
 17305  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17306  				return err
 17307  			}
 17308  		}
 17309  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17310  			return err
 17311  		}
 17312  	}
 17313  	if err := tp.ReadStructEnd(ctx); err != nil {
 17314  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17315  	}
 17316  	return nil
 17317  }
 17318  
 17319  func (p *SRandMemberArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 17320  	if v, err := tp.ReadString(ctx); err != nil {
 17321  		return thrift.PrependError("error reading field 1: ", err)
 17322  	} else {
 17323  		p.Appid = v
 17324  	}
 17325  	return nil
 17326  }
 17327  
 17328  func (p *SRandMemberArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 17329  	if v, err := tp.ReadString(ctx); err != nil {
 17330  		return thrift.PrependError("error reading field 2: ", err)
 17331  	} else {
 17332  		p.Key = v
 17333  	}
 17334  	return nil
 17335  }
 17336  
 17337  func (p *SRandMemberArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 17338  	if err := tp.WriteStructBegin(ctx, "SRandMember_args"); err != nil {
 17339  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17340  	}
 17341  	if p != nil {
 17342  		if err := p.writeField1(ctx, tp); err != nil {
 17343  			return err
 17344  		}
 17345  		if err := p.writeField2(ctx, tp); err != nil {
 17346  			return err
 17347  		}
 17348  	}
 17349  	if err := tp.WriteFieldStop(ctx); err != nil {
 17350  		return thrift.PrependError("write field stop error: ", err)
 17351  	}
 17352  	if err := tp.WriteStructEnd(ctx); err != nil {
 17353  		return thrift.PrependError("write struct stop error: ", err)
 17354  	}
 17355  	return nil
 17356  }
 17357  
 17358  func (p *SRandMemberArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 17359  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 17360  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 17361  	}
 17362  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 17363  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 17364  	}
 17365  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17366  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 17367  	}
 17368  	return err
 17369  }
 17370  
 17371  func (p *SRandMemberArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 17372  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 17373  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 17374  	}
 17375  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 17376  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 17377  	}
 17378  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17379  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 17380  	}
 17381  	return err
 17382  }
 17383  
 17384  func (p *SRandMemberArgs) String() string {
 17385  	if p == nil {
 17386  		return "<nil>"
 17387  	}
 17388  	return fmt.Sprintf("SRandMemberArgs(%+v)", *p)
 17389  }
 17390  
 17391  // Attributes:
 17392  //  - Success
 17393  type SRandMemberResult struct {
 17394  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 17395  }
 17396  
 17397  func NewSRandMemberResult() *SRandMemberResult {
 17398  	return &SRandMemberResult{}
 17399  }
 17400  
 17401  var SRandMemberResult_Success_DEFAULT *Response
 17402  
 17403  func (p *SRandMemberResult) GetSuccess() *Response {
 17404  	if !p.IsSetSuccess() {
 17405  		return SRandMemberResult_Success_DEFAULT
 17406  	}
 17407  	return p.Success
 17408  }
 17409  func (p *SRandMemberResult) IsSetSuccess() bool {
 17410  	return p.Success != nil
 17411  }
 17412  
 17413  func (p *SRandMemberResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 17414  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17415  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17416  	}
 17417  
 17418  	for {
 17419  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17420  		if err != nil {
 17421  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17422  		}
 17423  		if fieldTypeId == thrift.STOP {
 17424  			break
 17425  		}
 17426  		switch fieldId {
 17427  		case 0:
 17428  			if fieldTypeId == thrift.STRUCT {
 17429  				if err := p.ReadField0(ctx, tp); err != nil {
 17430  					return err
 17431  				}
 17432  			} else {
 17433  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17434  					return err
 17435  				}
 17436  			}
 17437  		default:
 17438  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17439  				return err
 17440  			}
 17441  		}
 17442  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17443  			return err
 17444  		}
 17445  	}
 17446  	if err := tp.ReadStructEnd(ctx); err != nil {
 17447  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17448  	}
 17449  	return nil
 17450  }
 17451  
 17452  func (p *SRandMemberResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 17453  	p.Success = &Response{}
 17454  	if err := p.Success.Read(ctx, tp); err != nil {
 17455  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 17456  	}
 17457  	return nil
 17458  }
 17459  
 17460  func (p *SRandMemberResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 17461  	if err := tp.WriteStructBegin(ctx, "SRandMember_result"); err != nil {
 17462  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17463  	}
 17464  	if p != nil {
 17465  		if err := p.writeField0(ctx, tp); err != nil {
 17466  			return err
 17467  		}
 17468  	}
 17469  	if err := tp.WriteFieldStop(ctx); err != nil {
 17470  		return thrift.PrependError("write field stop error: ", err)
 17471  	}
 17472  	if err := tp.WriteStructEnd(ctx); err != nil {
 17473  		return thrift.PrependError("write struct stop error: ", err)
 17474  	}
 17475  	return nil
 17476  }
 17477  
 17478  func (p *SRandMemberResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 17479  	if p.IsSetSuccess() {
 17480  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 17481  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 17482  		}
 17483  		if err := p.Success.Write(ctx, tp); err != nil {
 17484  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 17485  		}
 17486  		if err := tp.WriteFieldEnd(ctx); err != nil {
 17487  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 17488  		}
 17489  	}
 17490  	return err
 17491  }
 17492  
 17493  func (p *SRandMemberResult) String() string {
 17494  	if p == nil {
 17495  		return "<nil>"
 17496  	}
 17497  	return fmt.Sprintf("SRandMemberResult(%+v)", *p)
 17498  }
 17499  
 17500  // Attributes:
 17501  //  - Appid
 17502  //  - Key
 17503  //  - N
 17504  type SRandMemberNArgs struct {
 17505  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 17506  	Key   string `thrift:"key,2" db:"key" json:"key"`
 17507  	N     int64  `thrift:"n,3" db:"n" json:"n"`
 17508  }
 17509  
 17510  func NewSRandMemberNArgs() *SRandMemberNArgs {
 17511  	return &SRandMemberNArgs{}
 17512  }
 17513  
 17514  func (p *SRandMemberNArgs) GetAppid() string {
 17515  	return p.Appid
 17516  }
 17517  
 17518  func (p *SRandMemberNArgs) GetKey() string {
 17519  	return p.Key
 17520  }
 17521  
 17522  func (p *SRandMemberNArgs) GetN() int64 {
 17523  	return p.N
 17524  }
 17525  func (p *SRandMemberNArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 17526  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17527  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17528  	}
 17529  
 17530  	for {
 17531  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17532  		if err != nil {
 17533  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17534  		}
 17535  		if fieldTypeId == thrift.STOP {
 17536  			break
 17537  		}
 17538  		switch fieldId {
 17539  		case 1:
 17540  			if fieldTypeId == thrift.STRING {
 17541  				if err := p.ReadField1(ctx, tp); err != nil {
 17542  					return err
 17543  				}
 17544  			} else {
 17545  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17546  					return err
 17547  				}
 17548  			}
 17549  		case 2:
 17550  			if fieldTypeId == thrift.STRING {
 17551  				if err := p.ReadField2(ctx, tp); err != nil {
 17552  					return err
 17553  				}
 17554  			} else {
 17555  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17556  					return err
 17557  				}
 17558  			}
 17559  		case 3:
 17560  			if fieldTypeId == thrift.I64 {
 17561  				if err := p.ReadField3(ctx, tp); err != nil {
 17562  					return err
 17563  				}
 17564  			} else {
 17565  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17566  					return err
 17567  				}
 17568  			}
 17569  		default:
 17570  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17571  				return err
 17572  			}
 17573  		}
 17574  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17575  			return err
 17576  		}
 17577  	}
 17578  	if err := tp.ReadStructEnd(ctx); err != nil {
 17579  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17580  	}
 17581  	return nil
 17582  }
 17583  
 17584  func (p *SRandMemberNArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 17585  	if v, err := tp.ReadString(ctx); err != nil {
 17586  		return thrift.PrependError("error reading field 1: ", err)
 17587  	} else {
 17588  		p.Appid = v
 17589  	}
 17590  	return nil
 17591  }
 17592  
 17593  func (p *SRandMemberNArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 17594  	if v, err := tp.ReadString(ctx); err != nil {
 17595  		return thrift.PrependError("error reading field 2: ", err)
 17596  	} else {
 17597  		p.Key = v
 17598  	}
 17599  	return nil
 17600  }
 17601  
 17602  func (p *SRandMemberNArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 17603  	if v, err := tp.ReadI64(ctx); err != nil {
 17604  		return thrift.PrependError("error reading field 3: ", err)
 17605  	} else {
 17606  		p.N = v
 17607  	}
 17608  	return nil
 17609  }
 17610  
 17611  func (p *SRandMemberNArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 17612  	if err := tp.WriteStructBegin(ctx, "SRandMemberN_args"); err != nil {
 17613  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17614  	}
 17615  	if p != nil {
 17616  		if err := p.writeField1(ctx, tp); err != nil {
 17617  			return err
 17618  		}
 17619  		if err := p.writeField2(ctx, tp); err != nil {
 17620  			return err
 17621  		}
 17622  		if err := p.writeField3(ctx, tp); err != nil {
 17623  			return err
 17624  		}
 17625  	}
 17626  	if err := tp.WriteFieldStop(ctx); err != nil {
 17627  		return thrift.PrependError("write field stop error: ", err)
 17628  	}
 17629  	if err := tp.WriteStructEnd(ctx); err != nil {
 17630  		return thrift.PrependError("write struct stop error: ", err)
 17631  	}
 17632  	return nil
 17633  }
 17634  
 17635  func (p *SRandMemberNArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 17636  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 17637  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 17638  	}
 17639  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 17640  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 17641  	}
 17642  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17643  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 17644  	}
 17645  	return err
 17646  }
 17647  
 17648  func (p *SRandMemberNArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 17649  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 17650  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 17651  	}
 17652  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 17653  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 17654  	}
 17655  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17656  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 17657  	}
 17658  	return err
 17659  }
 17660  
 17661  func (p *SRandMemberNArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 17662  	if err := tp.WriteFieldBegin(ctx, "n", thrift.I64, 3); err != nil {
 17663  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:n: ", p), err)
 17664  	}
 17665  	if err := tp.WriteI64(ctx, int64(p.N)); err != nil {
 17666  		return thrift.PrependError(fmt.Sprintf("%T.n (3) field write error: ", p), err)
 17667  	}
 17668  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17669  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:n: ", p), err)
 17670  	}
 17671  	return err
 17672  }
 17673  
 17674  func (p *SRandMemberNArgs) String() string {
 17675  	if p == nil {
 17676  		return "<nil>"
 17677  	}
 17678  	return fmt.Sprintf("SRandMemberNArgs(%+v)", *p)
 17679  }
 17680  
 17681  // Attributes:
 17682  //  - Success
 17683  type SRandMemberNResult struct {
 17684  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 17685  }
 17686  
 17687  func NewSRandMemberNResult() *SRandMemberNResult {
 17688  	return &SRandMemberNResult{}
 17689  }
 17690  
 17691  var SRandMemberNResult_Success_DEFAULT *LResponse
 17692  
 17693  func (p *SRandMemberNResult) GetSuccess() *LResponse {
 17694  	if !p.IsSetSuccess() {
 17695  		return SRandMemberNResult_Success_DEFAULT
 17696  	}
 17697  	return p.Success
 17698  }
 17699  func (p *SRandMemberNResult) IsSetSuccess() bool {
 17700  	return p.Success != nil
 17701  }
 17702  
 17703  func (p *SRandMemberNResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 17704  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17705  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17706  	}
 17707  
 17708  	for {
 17709  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17710  		if err != nil {
 17711  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17712  		}
 17713  		if fieldTypeId == thrift.STOP {
 17714  			break
 17715  		}
 17716  		switch fieldId {
 17717  		case 0:
 17718  			if fieldTypeId == thrift.STRUCT {
 17719  				if err := p.ReadField0(ctx, tp); err != nil {
 17720  					return err
 17721  				}
 17722  			} else {
 17723  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17724  					return err
 17725  				}
 17726  			}
 17727  		default:
 17728  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17729  				return err
 17730  			}
 17731  		}
 17732  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17733  			return err
 17734  		}
 17735  	}
 17736  	if err := tp.ReadStructEnd(ctx); err != nil {
 17737  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17738  	}
 17739  	return nil
 17740  }
 17741  
 17742  func (p *SRandMemberNResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 17743  	p.Success = &LResponse{}
 17744  	if err := p.Success.Read(ctx, tp); err != nil {
 17745  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 17746  	}
 17747  	return nil
 17748  }
 17749  
 17750  func (p *SRandMemberNResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 17751  	if err := tp.WriteStructBegin(ctx, "SRandMemberN_result"); err != nil {
 17752  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17753  	}
 17754  	if p != nil {
 17755  		if err := p.writeField0(ctx, tp); err != nil {
 17756  			return err
 17757  		}
 17758  	}
 17759  	if err := tp.WriteFieldStop(ctx); err != nil {
 17760  		return thrift.PrependError("write field stop error: ", err)
 17761  	}
 17762  	if err := tp.WriteStructEnd(ctx); err != nil {
 17763  		return thrift.PrependError("write struct stop error: ", err)
 17764  	}
 17765  	return nil
 17766  }
 17767  
 17768  func (p *SRandMemberNResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 17769  	if p.IsSetSuccess() {
 17770  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 17771  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 17772  		}
 17773  		if err := p.Success.Write(ctx, tp); err != nil {
 17774  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 17775  		}
 17776  		if err := tp.WriteFieldEnd(ctx); err != nil {
 17777  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 17778  		}
 17779  	}
 17780  	return err
 17781  }
 17782  
 17783  func (p *SRandMemberNResult) String() string {
 17784  	if p == nil {
 17785  		return "<nil>"
 17786  	}
 17787  	return fmt.Sprintf("SRandMemberNResult(%+v)", *p)
 17788  }
 17789  
 17790  // Attributes:
 17791  //  - Appid
 17792  //  - Key
 17793  //  - Member
 17794  type SRemArgs struct {
 17795  	Appid  string `thrift:"appid,1" db:"appid" json:"appid"`
 17796  	Key    string `thrift:"key,2" db:"key" json:"key"`
 17797  	Member string `thrift:"member,3" db:"member" json:"member"`
 17798  }
 17799  
 17800  func NewSRemArgs() *SRemArgs {
 17801  	return &SRemArgs{}
 17802  }
 17803  
 17804  func (p *SRemArgs) GetAppid() string {
 17805  	return p.Appid
 17806  }
 17807  
 17808  func (p *SRemArgs) GetKey() string {
 17809  	return p.Key
 17810  }
 17811  
 17812  func (p *SRemArgs) GetMember() string {
 17813  	return p.Member
 17814  }
 17815  func (p *SRemArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 17816  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17817  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17818  	}
 17819  
 17820  	for {
 17821  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 17822  		if err != nil {
 17823  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 17824  		}
 17825  		if fieldTypeId == thrift.STOP {
 17826  			break
 17827  		}
 17828  		switch fieldId {
 17829  		case 1:
 17830  			if fieldTypeId == thrift.STRING {
 17831  				if err := p.ReadField1(ctx, tp); err != nil {
 17832  					return err
 17833  				}
 17834  			} else {
 17835  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17836  					return err
 17837  				}
 17838  			}
 17839  		case 2:
 17840  			if fieldTypeId == thrift.STRING {
 17841  				if err := p.ReadField2(ctx, tp); err != nil {
 17842  					return err
 17843  				}
 17844  			} else {
 17845  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17846  					return err
 17847  				}
 17848  			}
 17849  		case 3:
 17850  			if fieldTypeId == thrift.STRING {
 17851  				if err := p.ReadField3(ctx, tp); err != nil {
 17852  					return err
 17853  				}
 17854  			} else {
 17855  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17856  					return err
 17857  				}
 17858  			}
 17859  		default:
 17860  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 17861  				return err
 17862  			}
 17863  		}
 17864  		if err := tp.ReadFieldEnd(ctx); err != nil {
 17865  			return err
 17866  		}
 17867  	}
 17868  	if err := tp.ReadStructEnd(ctx); err != nil {
 17869  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 17870  	}
 17871  	return nil
 17872  }
 17873  
 17874  func (p *SRemArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 17875  	if v, err := tp.ReadString(ctx); err != nil {
 17876  		return thrift.PrependError("error reading field 1: ", err)
 17877  	} else {
 17878  		p.Appid = v
 17879  	}
 17880  	return nil
 17881  }
 17882  
 17883  func (p *SRemArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 17884  	if v, err := tp.ReadString(ctx); err != nil {
 17885  		return thrift.PrependError("error reading field 2: ", err)
 17886  	} else {
 17887  		p.Key = v
 17888  	}
 17889  	return nil
 17890  }
 17891  
 17892  func (p *SRemArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 17893  	if v, err := tp.ReadString(ctx); err != nil {
 17894  		return thrift.PrependError("error reading field 3: ", err)
 17895  	} else {
 17896  		p.Member = v
 17897  	}
 17898  	return nil
 17899  }
 17900  
 17901  func (p *SRemArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 17902  	if err := tp.WriteStructBegin(ctx, "SRem_args"); err != nil {
 17903  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 17904  	}
 17905  	if p != nil {
 17906  		if err := p.writeField1(ctx, tp); err != nil {
 17907  			return err
 17908  		}
 17909  		if err := p.writeField2(ctx, tp); err != nil {
 17910  			return err
 17911  		}
 17912  		if err := p.writeField3(ctx, tp); err != nil {
 17913  			return err
 17914  		}
 17915  	}
 17916  	if err := tp.WriteFieldStop(ctx); err != nil {
 17917  		return thrift.PrependError("write field stop error: ", err)
 17918  	}
 17919  	if err := tp.WriteStructEnd(ctx); err != nil {
 17920  		return thrift.PrependError("write struct stop error: ", err)
 17921  	}
 17922  	return nil
 17923  }
 17924  
 17925  func (p *SRemArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 17926  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 17927  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 17928  	}
 17929  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 17930  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 17931  	}
 17932  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17933  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 17934  	}
 17935  	return err
 17936  }
 17937  
 17938  func (p *SRemArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 17939  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 17940  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 17941  	}
 17942  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 17943  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 17944  	}
 17945  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17946  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 17947  	}
 17948  	return err
 17949  }
 17950  
 17951  func (p *SRemArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 17952  	if err := tp.WriteFieldBegin(ctx, "member", thrift.STRING, 3); err != nil {
 17953  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 17954  	}
 17955  	if err := tp.WriteString(ctx, string(p.Member)); err != nil {
 17956  		return thrift.PrependError(fmt.Sprintf("%T.member (3) field write error: ", p), err)
 17957  	}
 17958  	if err := tp.WriteFieldEnd(ctx); err != nil {
 17959  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 17960  	}
 17961  	return err
 17962  }
 17963  
 17964  func (p *SRemArgs) String() string {
 17965  	if p == nil {
 17966  		return "<nil>"
 17967  	}
 17968  	return fmt.Sprintf("SRemArgs(%+v)", *p)
 17969  }
 17970  
 17971  // Attributes:
 17972  //  - Success
 17973  type SRemResult struct {
 17974  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 17975  }
 17976  
 17977  func NewSRemResult() *SRemResult {
 17978  	return &SRemResult{}
 17979  }
 17980  
 17981  var SRemResult_Success_DEFAULT *IntResponse
 17982  
 17983  func (p *SRemResult) GetSuccess() *IntResponse {
 17984  	if !p.IsSetSuccess() {
 17985  		return SRemResult_Success_DEFAULT
 17986  	}
 17987  	return p.Success
 17988  }
 17989  func (p *SRemResult) IsSetSuccess() bool {
 17990  	return p.Success != nil
 17991  }
 17992  
 17993  func (p *SRemResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 17994  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 17995  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 17996  	}
 17997  
 17998  	for {
 17999  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18000  		if err != nil {
 18001  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18002  		}
 18003  		if fieldTypeId == thrift.STOP {
 18004  			break
 18005  		}
 18006  		switch fieldId {
 18007  		case 0:
 18008  			if fieldTypeId == thrift.STRUCT {
 18009  				if err := p.ReadField0(ctx, tp); err != nil {
 18010  					return err
 18011  				}
 18012  			} else {
 18013  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18014  					return err
 18015  				}
 18016  			}
 18017  		default:
 18018  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18019  				return err
 18020  			}
 18021  		}
 18022  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18023  			return err
 18024  		}
 18025  	}
 18026  	if err := tp.ReadStructEnd(ctx); err != nil {
 18027  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18028  	}
 18029  	return nil
 18030  }
 18031  
 18032  func (p *SRemResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 18033  	p.Success = &IntResponse{}
 18034  	if err := p.Success.Read(ctx, tp); err != nil {
 18035  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 18036  	}
 18037  	return nil
 18038  }
 18039  
 18040  func (p *SRemResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 18041  	if err := tp.WriteStructBegin(ctx, "SRem_result"); err != nil {
 18042  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18043  	}
 18044  	if p != nil {
 18045  		if err := p.writeField0(ctx, tp); err != nil {
 18046  			return err
 18047  		}
 18048  	}
 18049  	if err := tp.WriteFieldStop(ctx); err != nil {
 18050  		return thrift.PrependError("write field stop error: ", err)
 18051  	}
 18052  	if err := tp.WriteStructEnd(ctx); err != nil {
 18053  		return thrift.PrependError("write struct stop error: ", err)
 18054  	}
 18055  	return nil
 18056  }
 18057  
 18058  func (p *SRemResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 18059  	if p.IsSetSuccess() {
 18060  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 18061  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 18062  		}
 18063  		if err := p.Success.Write(ctx, tp); err != nil {
 18064  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 18065  		}
 18066  		if err := tp.WriteFieldEnd(ctx); err != nil {
 18067  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 18068  		}
 18069  	}
 18070  	return err
 18071  }
 18072  
 18073  func (p *SRemResult) String() string {
 18074  	if p == nil {
 18075  		return "<nil>"
 18076  	}
 18077  	return fmt.Sprintf("SRemResult(%+v)", *p)
 18078  }
 18079  
 18080  // Attributes:
 18081  //  - Appid
 18082  //  - Key
 18083  //  - Member
 18084  type MsRemArgs struct {
 18085  	Appid  string   `thrift:"appid,1" db:"appid" json:"appid"`
 18086  	Key    string   `thrift:"key,2" db:"key" json:"key"`
 18087  	Member []string `thrift:"member,3" db:"member" json:"member"`
 18088  }
 18089  
 18090  func NewMSRemArgs() *MsRemArgs {
 18091  	return &MsRemArgs{}
 18092  }
 18093  
 18094  func (p *MsRemArgs) GetAppid() string {
 18095  	return p.Appid
 18096  }
 18097  
 18098  func (p *MsRemArgs) GetKey() string {
 18099  	return p.Key
 18100  }
 18101  
 18102  func (p *MsRemArgs) GetMember() []string {
 18103  	return p.Member
 18104  }
 18105  func (p *MsRemArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 18106  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18107  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18108  	}
 18109  
 18110  	for {
 18111  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18112  		if err != nil {
 18113  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18114  		}
 18115  		if fieldTypeId == thrift.STOP {
 18116  			break
 18117  		}
 18118  		switch fieldId {
 18119  		case 1:
 18120  			if fieldTypeId == thrift.STRING {
 18121  				if err := p.ReadField1(ctx, tp); err != nil {
 18122  					return err
 18123  				}
 18124  			} else {
 18125  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18126  					return err
 18127  				}
 18128  			}
 18129  		case 2:
 18130  			if fieldTypeId == thrift.STRING {
 18131  				if err := p.ReadField2(ctx, tp); err != nil {
 18132  					return err
 18133  				}
 18134  			} else {
 18135  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18136  					return err
 18137  				}
 18138  			}
 18139  		case 3:
 18140  			if fieldTypeId == thrift.LIST {
 18141  				if err := p.ReadField3(ctx, tp); err != nil {
 18142  					return err
 18143  				}
 18144  			} else {
 18145  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18146  					return err
 18147  				}
 18148  			}
 18149  		default:
 18150  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18151  				return err
 18152  			}
 18153  		}
 18154  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18155  			return err
 18156  		}
 18157  	}
 18158  	if err := tp.ReadStructEnd(ctx); err != nil {
 18159  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18160  	}
 18161  	return nil
 18162  }
 18163  
 18164  func (p *MsRemArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 18165  	if v, err := tp.ReadString(ctx); err != nil {
 18166  		return thrift.PrependError("error reading field 1: ", err)
 18167  	} else {
 18168  		p.Appid = v
 18169  	}
 18170  	return nil
 18171  }
 18172  
 18173  func (p *MsRemArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 18174  	if v, err := tp.ReadString(ctx); err != nil {
 18175  		return thrift.PrependError("error reading field 2: ", err)
 18176  	} else {
 18177  		p.Key = v
 18178  	}
 18179  	return nil
 18180  }
 18181  
 18182  func (p *MsRemArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 18183  	_, size, err := tp.ReadListBegin(ctx)
 18184  	if err != nil {
 18185  		return thrift.PrependError("error reading list begin: ", err)
 18186  	}
 18187  	tSlice := make([]string, 0, size)
 18188  	p.Member = tSlice
 18189  	for i := 0; i < size; i++ {
 18190  		var _elem196 string
 18191  		if v, err := tp.ReadString(ctx); err != nil {
 18192  			return thrift.PrependError("error reading field 0: ", err)
 18193  		} else {
 18194  			_elem196 = v
 18195  		}
 18196  		p.Member = append(p.Member, _elem196)
 18197  	}
 18198  	if err := tp.ReadListEnd(ctx); err != nil {
 18199  		return thrift.PrependError("error reading list end: ", err)
 18200  	}
 18201  	return nil
 18202  }
 18203  
 18204  func (p *MsRemArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 18205  	if err := tp.WriteStructBegin(ctx, "MSRem_args"); err != nil {
 18206  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18207  	}
 18208  	if p != nil {
 18209  		if err := p.writeField1(ctx, tp); err != nil {
 18210  			return err
 18211  		}
 18212  		if err := p.writeField2(ctx, tp); err != nil {
 18213  			return err
 18214  		}
 18215  		if err := p.writeField3(ctx, tp); err != nil {
 18216  			return err
 18217  		}
 18218  	}
 18219  	if err := tp.WriteFieldStop(ctx); err != nil {
 18220  		return thrift.PrependError("write field stop error: ", err)
 18221  	}
 18222  	if err := tp.WriteStructEnd(ctx); err != nil {
 18223  		return thrift.PrependError("write struct stop error: ", err)
 18224  	}
 18225  	return nil
 18226  }
 18227  
 18228  func (p *MsRemArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 18229  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 18230  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 18231  	}
 18232  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 18233  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 18234  	}
 18235  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18236  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 18237  	}
 18238  	return err
 18239  }
 18240  
 18241  func (p *MsRemArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 18242  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 18243  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 18244  	}
 18245  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 18246  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 18247  	}
 18248  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18249  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 18250  	}
 18251  	return err
 18252  }
 18253  
 18254  func (p *MsRemArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 18255  	if err := tp.WriteFieldBegin(ctx, "member", thrift.LIST, 3); err != nil {
 18256  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:member: ", p), err)
 18257  	}
 18258  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Member)); err != nil {
 18259  		return thrift.PrependError("error writing list begin: ", err)
 18260  	}
 18261  	for _, v := range p.Member {
 18262  		if err := tp.WriteString(ctx, string(v)); err != nil {
 18263  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 18264  		}
 18265  	}
 18266  	if err := tp.WriteListEnd(ctx); err != nil {
 18267  		return thrift.PrependError("error writing list end: ", err)
 18268  	}
 18269  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18270  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:member: ", p), err)
 18271  	}
 18272  	return err
 18273  }
 18274  
 18275  func (p *MsRemArgs) String() string {
 18276  	if p == nil {
 18277  		return "<nil>"
 18278  	}
 18279  	return fmt.Sprintf("MsRemArgs(%+v)", *p)
 18280  }
 18281  
 18282  // Attributes:
 18283  //  - Success
 18284  type MsRemResult struct {
 18285  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 18286  }
 18287  
 18288  func NewMSRemResult() *MsRemResult {
 18289  	return &MsRemResult{}
 18290  }
 18291  
 18292  var MSRemResult_Success_DEFAULT *IntResponse
 18293  
 18294  func (p *MsRemResult) GetSuccess() *IntResponse {
 18295  	if !p.IsSetSuccess() {
 18296  		return MSRemResult_Success_DEFAULT
 18297  	}
 18298  	return p.Success
 18299  }
 18300  func (p *MsRemResult) IsSetSuccess() bool {
 18301  	return p.Success != nil
 18302  }
 18303  
 18304  func (p *MsRemResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 18305  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18306  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18307  	}
 18308  
 18309  	for {
 18310  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18311  		if err != nil {
 18312  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18313  		}
 18314  		if fieldTypeId == thrift.STOP {
 18315  			break
 18316  		}
 18317  		switch fieldId {
 18318  		case 0:
 18319  			if fieldTypeId == thrift.STRUCT {
 18320  				if err := p.ReadField0(ctx, tp); err != nil {
 18321  					return err
 18322  				}
 18323  			} else {
 18324  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18325  					return err
 18326  				}
 18327  			}
 18328  		default:
 18329  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18330  				return err
 18331  			}
 18332  		}
 18333  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18334  			return err
 18335  		}
 18336  	}
 18337  	if err := tp.ReadStructEnd(ctx); err != nil {
 18338  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18339  	}
 18340  	return nil
 18341  }
 18342  
 18343  func (p *MsRemResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 18344  	p.Success = &IntResponse{}
 18345  	if err := p.Success.Read(ctx, tp); err != nil {
 18346  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 18347  	}
 18348  	return nil
 18349  }
 18350  
 18351  func (p *MsRemResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 18352  	if err := tp.WriteStructBegin(ctx, "MSRem_result"); err != nil {
 18353  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18354  	}
 18355  	if p != nil {
 18356  		if err := p.writeField0(ctx, tp); err != nil {
 18357  			return err
 18358  		}
 18359  	}
 18360  	if err := tp.WriteFieldStop(ctx); err != nil {
 18361  		return thrift.PrependError("write field stop error: ", err)
 18362  	}
 18363  	if err := tp.WriteStructEnd(ctx); err != nil {
 18364  		return thrift.PrependError("write struct stop error: ", err)
 18365  	}
 18366  	return nil
 18367  }
 18368  
 18369  func (p *MsRemResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 18370  	if p.IsSetSuccess() {
 18371  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 18372  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 18373  		}
 18374  		if err := p.Success.Write(ctx, tp); err != nil {
 18375  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 18376  		}
 18377  		if err := tp.WriteFieldEnd(ctx); err != nil {
 18378  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 18379  		}
 18380  	}
 18381  	return err
 18382  }
 18383  
 18384  func (p *MsRemResult) String() string {
 18385  	if p == nil {
 18386  		return "<nil>"
 18387  	}
 18388  	return fmt.Sprintf("MsRemResult(%+v)", *p)
 18389  }
 18390  
 18391  // Attributes:
 18392  //  - Appid
 18393  //  - Key
 18394  //  - Value
 18395  type LPushArgs struct {
 18396  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 18397  	Key   string `thrift:"key,2" db:"key" json:"key"`
 18398  	Value string `thrift:"value,3" db:"value" json:"value"`
 18399  }
 18400  
 18401  func NewLPushArgs() *LPushArgs {
 18402  	return &LPushArgs{}
 18403  }
 18404  
 18405  func (p *LPushArgs) GetAppid() string {
 18406  	return p.Appid
 18407  }
 18408  
 18409  func (p *LPushArgs) GetKey() string {
 18410  	return p.Key
 18411  }
 18412  
 18413  func (p *LPushArgs) GetValue() string {
 18414  	return p.Value
 18415  }
 18416  func (p *LPushArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 18417  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18418  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18419  	}
 18420  
 18421  	for {
 18422  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18423  		if err != nil {
 18424  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18425  		}
 18426  		if fieldTypeId == thrift.STOP {
 18427  			break
 18428  		}
 18429  		switch fieldId {
 18430  		case 1:
 18431  			if fieldTypeId == thrift.STRING {
 18432  				if err := p.ReadField1(ctx, tp); err != nil {
 18433  					return err
 18434  				}
 18435  			} else {
 18436  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18437  					return err
 18438  				}
 18439  			}
 18440  		case 2:
 18441  			if fieldTypeId == thrift.STRING {
 18442  				if err := p.ReadField2(ctx, tp); err != nil {
 18443  					return err
 18444  				}
 18445  			} else {
 18446  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18447  					return err
 18448  				}
 18449  			}
 18450  		case 3:
 18451  			if fieldTypeId == thrift.STRING {
 18452  				if err := p.ReadField3(ctx, tp); err != nil {
 18453  					return err
 18454  				}
 18455  			} else {
 18456  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18457  					return err
 18458  				}
 18459  			}
 18460  		default:
 18461  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18462  				return err
 18463  			}
 18464  		}
 18465  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18466  			return err
 18467  		}
 18468  	}
 18469  	if err := tp.ReadStructEnd(ctx); err != nil {
 18470  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18471  	}
 18472  	return nil
 18473  }
 18474  
 18475  func (p *LPushArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 18476  	if v, err := tp.ReadString(ctx); err != nil {
 18477  		return thrift.PrependError("error reading field 1: ", err)
 18478  	} else {
 18479  		p.Appid = v
 18480  	}
 18481  	return nil
 18482  }
 18483  
 18484  func (p *LPushArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 18485  	if v, err := tp.ReadString(ctx); err != nil {
 18486  		return thrift.PrependError("error reading field 2: ", err)
 18487  	} else {
 18488  		p.Key = v
 18489  	}
 18490  	return nil
 18491  }
 18492  
 18493  func (p *LPushArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 18494  	if v, err := tp.ReadString(ctx); err != nil {
 18495  		return thrift.PrependError("error reading field 3: ", err)
 18496  	} else {
 18497  		p.Value = v
 18498  	}
 18499  	return nil
 18500  }
 18501  
 18502  func (p *LPushArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 18503  	if err := tp.WriteStructBegin(ctx, "LPush_args"); err != nil {
 18504  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18505  	}
 18506  	if p != nil {
 18507  		if err := p.writeField1(ctx, tp); err != nil {
 18508  			return err
 18509  		}
 18510  		if err := p.writeField2(ctx, tp); err != nil {
 18511  			return err
 18512  		}
 18513  		if err := p.writeField3(ctx, tp); err != nil {
 18514  			return err
 18515  		}
 18516  	}
 18517  	if err := tp.WriteFieldStop(ctx); err != nil {
 18518  		return thrift.PrependError("write field stop error: ", err)
 18519  	}
 18520  	if err := tp.WriteStructEnd(ctx); err != nil {
 18521  		return thrift.PrependError("write struct stop error: ", err)
 18522  	}
 18523  	return nil
 18524  }
 18525  
 18526  func (p *LPushArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 18527  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 18528  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 18529  	}
 18530  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 18531  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 18532  	}
 18533  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18534  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 18535  	}
 18536  	return err
 18537  }
 18538  
 18539  func (p *LPushArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 18540  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 18541  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 18542  	}
 18543  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 18544  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 18545  	}
 18546  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18547  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 18548  	}
 18549  	return err
 18550  }
 18551  
 18552  func (p *LPushArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 18553  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
 18554  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 18555  	}
 18556  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
 18557  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
 18558  	}
 18559  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18560  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 18561  	}
 18562  	return err
 18563  }
 18564  
 18565  func (p *LPushArgs) String() string {
 18566  	if p == nil {
 18567  		return "<nil>"
 18568  	}
 18569  	return fmt.Sprintf("LPushArgs(%+v)", *p)
 18570  }
 18571  
 18572  // Attributes:
 18573  //  - Success
 18574  type LPushResult struct {
 18575  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 18576  }
 18577  
 18578  func NewLPushResult() *LPushResult {
 18579  	return &LPushResult{}
 18580  }
 18581  
 18582  var LPushResult_Success_DEFAULT *IntResponse
 18583  
 18584  func (p *LPushResult) GetSuccess() *IntResponse {
 18585  	if !p.IsSetSuccess() {
 18586  		return LPushResult_Success_DEFAULT
 18587  	}
 18588  	return p.Success
 18589  }
 18590  func (p *LPushResult) IsSetSuccess() bool {
 18591  	return p.Success != nil
 18592  }
 18593  
 18594  func (p *LPushResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 18595  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18596  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18597  	}
 18598  
 18599  	for {
 18600  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18601  		if err != nil {
 18602  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18603  		}
 18604  		if fieldTypeId == thrift.STOP {
 18605  			break
 18606  		}
 18607  		switch fieldId {
 18608  		case 0:
 18609  			if fieldTypeId == thrift.STRUCT {
 18610  				if err := p.ReadField0(ctx, tp); err != nil {
 18611  					return err
 18612  				}
 18613  			} else {
 18614  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18615  					return err
 18616  				}
 18617  			}
 18618  		default:
 18619  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18620  				return err
 18621  			}
 18622  		}
 18623  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18624  			return err
 18625  		}
 18626  	}
 18627  	if err := tp.ReadStructEnd(ctx); err != nil {
 18628  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18629  	}
 18630  	return nil
 18631  }
 18632  
 18633  func (p *LPushResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 18634  	p.Success = &IntResponse{}
 18635  	if err := p.Success.Read(ctx, tp); err != nil {
 18636  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 18637  	}
 18638  	return nil
 18639  }
 18640  
 18641  func (p *LPushResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 18642  	if err := tp.WriteStructBegin(ctx, "LPush_result"); err != nil {
 18643  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18644  	}
 18645  	if p != nil {
 18646  		if err := p.writeField0(ctx, tp); err != nil {
 18647  			return err
 18648  		}
 18649  	}
 18650  	if err := tp.WriteFieldStop(ctx); err != nil {
 18651  		return thrift.PrependError("write field stop error: ", err)
 18652  	}
 18653  	if err := tp.WriteStructEnd(ctx); err != nil {
 18654  		return thrift.PrependError("write struct stop error: ", err)
 18655  	}
 18656  	return nil
 18657  }
 18658  
 18659  func (p *LPushResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 18660  	if p.IsSetSuccess() {
 18661  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 18662  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 18663  		}
 18664  		if err := p.Success.Write(ctx, tp); err != nil {
 18665  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 18666  		}
 18667  		if err := tp.WriteFieldEnd(ctx); err != nil {
 18668  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 18669  		}
 18670  	}
 18671  	return err
 18672  }
 18673  
 18674  func (p *LPushResult) String() string {
 18675  	if p == nil {
 18676  		return "<nil>"
 18677  	}
 18678  	return fmt.Sprintf("LPushResult(%+v)", *p)
 18679  }
 18680  
 18681  // Attributes:
 18682  //  - Appid
 18683  //  - Key
 18684  //  - Value
 18685  type LPushByteArgs struct {
 18686  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 18687  	Key   string `thrift:"key,2" db:"key" json:"key"`
 18688  	Value []byte `thrift:"value,3" db:"value" json:"value"`
 18689  }
 18690  
 18691  func NewLPushByteArgs() *LPushByteArgs {
 18692  	return &LPushByteArgs{}
 18693  }
 18694  
 18695  func (p *LPushByteArgs) GetAppid() string {
 18696  	return p.Appid
 18697  }
 18698  
 18699  func (p *LPushByteArgs) GetKey() string {
 18700  	return p.Key
 18701  }
 18702  
 18703  func (p *LPushByteArgs) GetValue() []byte {
 18704  	return p.Value
 18705  }
 18706  func (p *LPushByteArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 18707  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18708  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18709  	}
 18710  
 18711  	for {
 18712  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18713  		if err != nil {
 18714  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18715  		}
 18716  		if fieldTypeId == thrift.STOP {
 18717  			break
 18718  		}
 18719  		switch fieldId {
 18720  		case 1:
 18721  			if fieldTypeId == thrift.STRING {
 18722  				if err := p.ReadField1(ctx, tp); err != nil {
 18723  					return err
 18724  				}
 18725  			} else {
 18726  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18727  					return err
 18728  				}
 18729  			}
 18730  		case 2:
 18731  			if fieldTypeId == thrift.STRING {
 18732  				if err := p.ReadField2(ctx, tp); err != nil {
 18733  					return err
 18734  				}
 18735  			} else {
 18736  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18737  					return err
 18738  				}
 18739  			}
 18740  		case 3:
 18741  			if fieldTypeId == thrift.STRING {
 18742  				if err := p.ReadField3(ctx, tp); err != nil {
 18743  					return err
 18744  				}
 18745  			} else {
 18746  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18747  					return err
 18748  				}
 18749  			}
 18750  		default:
 18751  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18752  				return err
 18753  			}
 18754  		}
 18755  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18756  			return err
 18757  		}
 18758  	}
 18759  	if err := tp.ReadStructEnd(ctx); err != nil {
 18760  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18761  	}
 18762  	return nil
 18763  }
 18764  
 18765  func (p *LPushByteArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 18766  	if v, err := tp.ReadString(ctx); err != nil {
 18767  		return thrift.PrependError("error reading field 1: ", err)
 18768  	} else {
 18769  		p.Appid = v
 18770  	}
 18771  	return nil
 18772  }
 18773  
 18774  func (p *LPushByteArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 18775  	if v, err := tp.ReadString(ctx); err != nil {
 18776  		return thrift.PrependError("error reading field 2: ", err)
 18777  	} else {
 18778  		p.Key = v
 18779  	}
 18780  	return nil
 18781  }
 18782  
 18783  func (p *LPushByteArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 18784  	if v, err := tp.ReadBinary(ctx); err != nil {
 18785  		return thrift.PrependError("error reading field 3: ", err)
 18786  	} else {
 18787  		p.Value = v
 18788  	}
 18789  	return nil
 18790  }
 18791  
 18792  func (p *LPushByteArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 18793  	if err := tp.WriteStructBegin(ctx, "LPushByte_args"); err != nil {
 18794  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18795  	}
 18796  	if p != nil {
 18797  		if err := p.writeField1(ctx, tp); err != nil {
 18798  			return err
 18799  		}
 18800  		if err := p.writeField2(ctx, tp); err != nil {
 18801  			return err
 18802  		}
 18803  		if err := p.writeField3(ctx, tp); err != nil {
 18804  			return err
 18805  		}
 18806  	}
 18807  	if err := tp.WriteFieldStop(ctx); err != nil {
 18808  		return thrift.PrependError("write field stop error: ", err)
 18809  	}
 18810  	if err := tp.WriteStructEnd(ctx); err != nil {
 18811  		return thrift.PrependError("write struct stop error: ", err)
 18812  	}
 18813  	return nil
 18814  }
 18815  
 18816  func (p *LPushByteArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 18817  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 18818  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 18819  	}
 18820  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 18821  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 18822  	}
 18823  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18824  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 18825  	}
 18826  	return err
 18827  }
 18828  
 18829  func (p *LPushByteArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 18830  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 18831  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 18832  	}
 18833  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 18834  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 18835  	}
 18836  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18837  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 18838  	}
 18839  	return err
 18840  }
 18841  
 18842  func (p *LPushByteArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 18843  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
 18844  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 18845  	}
 18846  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
 18847  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
 18848  	}
 18849  	if err := tp.WriteFieldEnd(ctx); err != nil {
 18850  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 18851  	}
 18852  	return err
 18853  }
 18854  
 18855  func (p *LPushByteArgs) String() string {
 18856  	if p == nil {
 18857  		return "<nil>"
 18858  	}
 18859  	return fmt.Sprintf("LPushByteArgs(%+v)", *p)
 18860  }
 18861  
 18862  // Attributes:
 18863  //  - Success
 18864  type LPushByteResult struct {
 18865  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 18866  }
 18867  
 18868  func NewLPushByteResult() *LPushByteResult {
 18869  	return &LPushByteResult{}
 18870  }
 18871  
 18872  var LPushByteResult_Success_DEFAULT *IntResponse
 18873  
 18874  func (p *LPushByteResult) GetSuccess() *IntResponse {
 18875  	if !p.IsSetSuccess() {
 18876  		return LPushByteResult_Success_DEFAULT
 18877  	}
 18878  	return p.Success
 18879  }
 18880  func (p *LPushByteResult) IsSetSuccess() bool {
 18881  	return p.Success != nil
 18882  }
 18883  
 18884  func (p *LPushByteResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 18885  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18886  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18887  	}
 18888  
 18889  	for {
 18890  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 18891  		if err != nil {
 18892  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 18893  		}
 18894  		if fieldTypeId == thrift.STOP {
 18895  			break
 18896  		}
 18897  		switch fieldId {
 18898  		case 0:
 18899  			if fieldTypeId == thrift.STRUCT {
 18900  				if err := p.ReadField0(ctx, tp); err != nil {
 18901  					return err
 18902  				}
 18903  			} else {
 18904  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18905  					return err
 18906  				}
 18907  			}
 18908  		default:
 18909  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 18910  				return err
 18911  			}
 18912  		}
 18913  		if err := tp.ReadFieldEnd(ctx); err != nil {
 18914  			return err
 18915  		}
 18916  	}
 18917  	if err := tp.ReadStructEnd(ctx); err != nil {
 18918  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 18919  	}
 18920  	return nil
 18921  }
 18922  
 18923  func (p *LPushByteResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 18924  	p.Success = &IntResponse{}
 18925  	if err := p.Success.Read(ctx, tp); err != nil {
 18926  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 18927  	}
 18928  	return nil
 18929  }
 18930  
 18931  func (p *LPushByteResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 18932  	if err := tp.WriteStructBegin(ctx, "LPushByte_result"); err != nil {
 18933  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 18934  	}
 18935  	if p != nil {
 18936  		if err := p.writeField0(ctx, tp); err != nil {
 18937  			return err
 18938  		}
 18939  	}
 18940  	if err := tp.WriteFieldStop(ctx); err != nil {
 18941  		return thrift.PrependError("write field stop error: ", err)
 18942  	}
 18943  	if err := tp.WriteStructEnd(ctx); err != nil {
 18944  		return thrift.PrependError("write struct stop error: ", err)
 18945  	}
 18946  	return nil
 18947  }
 18948  
 18949  func (p *LPushByteResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 18950  	if p.IsSetSuccess() {
 18951  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 18952  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 18953  		}
 18954  		if err := p.Success.Write(ctx, tp); err != nil {
 18955  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 18956  		}
 18957  		if err := tp.WriteFieldEnd(ctx); err != nil {
 18958  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 18959  		}
 18960  	}
 18961  	return err
 18962  }
 18963  
 18964  func (p *LPushByteResult) String() string {
 18965  	if p == nil {
 18966  		return "<nil>"
 18967  	}
 18968  	return fmt.Sprintf("LPushByteResult(%+v)", *p)
 18969  }
 18970  
 18971  // Attributes:
 18972  //  - Appid
 18973  //  - Key
 18974  //  - Value
 18975  type RPushArgs struct {
 18976  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 18977  	Key   string `thrift:"key,2" db:"key" json:"key"`
 18978  	Value string `thrift:"value,3" db:"value" json:"value"`
 18979  }
 18980  
 18981  func NewRPushArgs() *RPushArgs {
 18982  	return &RPushArgs{}
 18983  }
 18984  
 18985  func (p *RPushArgs) GetAppid() string {
 18986  	return p.Appid
 18987  }
 18988  
 18989  func (p *RPushArgs) GetKey() string {
 18990  	return p.Key
 18991  }
 18992  
 18993  func (p *RPushArgs) GetValue() string {
 18994  	return p.Value
 18995  }
 18996  func (p *RPushArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 18997  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 18998  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 18999  	}
 19000  
 19001  	for {
 19002  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19003  		if err != nil {
 19004  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19005  		}
 19006  		if fieldTypeId == thrift.STOP {
 19007  			break
 19008  		}
 19009  		switch fieldId {
 19010  		case 1:
 19011  			if fieldTypeId == thrift.STRING {
 19012  				if err := p.ReadField1(ctx, tp); err != nil {
 19013  					return err
 19014  				}
 19015  			} else {
 19016  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19017  					return err
 19018  				}
 19019  			}
 19020  		case 2:
 19021  			if fieldTypeId == thrift.STRING {
 19022  				if err := p.ReadField2(ctx, tp); err != nil {
 19023  					return err
 19024  				}
 19025  			} else {
 19026  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19027  					return err
 19028  				}
 19029  			}
 19030  		case 3:
 19031  			if fieldTypeId == thrift.STRING {
 19032  				if err := p.ReadField3(ctx, tp); err != nil {
 19033  					return err
 19034  				}
 19035  			} else {
 19036  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19037  					return err
 19038  				}
 19039  			}
 19040  		default:
 19041  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19042  				return err
 19043  			}
 19044  		}
 19045  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19046  			return err
 19047  		}
 19048  	}
 19049  	if err := tp.ReadStructEnd(ctx); err != nil {
 19050  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19051  	}
 19052  	return nil
 19053  }
 19054  
 19055  func (p *RPushArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 19056  	if v, err := tp.ReadString(ctx); err != nil {
 19057  		return thrift.PrependError("error reading field 1: ", err)
 19058  	} else {
 19059  		p.Appid = v
 19060  	}
 19061  	return nil
 19062  }
 19063  
 19064  func (p *RPushArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 19065  	if v, err := tp.ReadString(ctx); err != nil {
 19066  		return thrift.PrependError("error reading field 2: ", err)
 19067  	} else {
 19068  		p.Key = v
 19069  	}
 19070  	return nil
 19071  }
 19072  
 19073  func (p *RPushArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 19074  	if v, err := tp.ReadString(ctx); err != nil {
 19075  		return thrift.PrependError("error reading field 3: ", err)
 19076  	} else {
 19077  		p.Value = v
 19078  	}
 19079  	return nil
 19080  }
 19081  
 19082  func (p *RPushArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 19083  	if err := tp.WriteStructBegin(ctx, "RPush_args"); err != nil {
 19084  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19085  	}
 19086  	if p != nil {
 19087  		if err := p.writeField1(ctx, tp); err != nil {
 19088  			return err
 19089  		}
 19090  		if err := p.writeField2(ctx, tp); err != nil {
 19091  			return err
 19092  		}
 19093  		if err := p.writeField3(ctx, tp); err != nil {
 19094  			return err
 19095  		}
 19096  	}
 19097  	if err := tp.WriteFieldStop(ctx); err != nil {
 19098  		return thrift.PrependError("write field stop error: ", err)
 19099  	}
 19100  	if err := tp.WriteStructEnd(ctx); err != nil {
 19101  		return thrift.PrependError("write struct stop error: ", err)
 19102  	}
 19103  	return nil
 19104  }
 19105  
 19106  func (p *RPushArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 19107  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 19108  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 19109  	}
 19110  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 19111  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 19112  	}
 19113  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19114  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 19115  	}
 19116  	return err
 19117  }
 19118  
 19119  func (p *RPushArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 19120  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 19121  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 19122  	}
 19123  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 19124  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 19125  	}
 19126  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19127  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 19128  	}
 19129  	return err
 19130  }
 19131  
 19132  func (p *RPushArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 19133  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
 19134  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 19135  	}
 19136  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
 19137  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
 19138  	}
 19139  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19140  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 19141  	}
 19142  	return err
 19143  }
 19144  
 19145  func (p *RPushArgs) String() string {
 19146  	if p == nil {
 19147  		return "<nil>"
 19148  	}
 19149  	return fmt.Sprintf("RPushArgs(%+v)", *p)
 19150  }
 19151  
 19152  // Attributes:
 19153  //  - Success
 19154  type RPushResult struct {
 19155  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 19156  }
 19157  
 19158  func NewRPushResult() *RPushResult {
 19159  	return &RPushResult{}
 19160  }
 19161  
 19162  var RPushResult_Success_DEFAULT *IntResponse
 19163  
 19164  func (p *RPushResult) GetSuccess() *IntResponse {
 19165  	if !p.IsSetSuccess() {
 19166  		return RPushResult_Success_DEFAULT
 19167  	}
 19168  	return p.Success
 19169  }
 19170  func (p *RPushResult) IsSetSuccess() bool {
 19171  	return p.Success != nil
 19172  }
 19173  
 19174  func (p *RPushResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 19175  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19176  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19177  	}
 19178  
 19179  	for {
 19180  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19181  		if err != nil {
 19182  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19183  		}
 19184  		if fieldTypeId == thrift.STOP {
 19185  			break
 19186  		}
 19187  		switch fieldId {
 19188  		case 0:
 19189  			if fieldTypeId == thrift.STRUCT {
 19190  				if err := p.ReadField0(ctx, tp); err != nil {
 19191  					return err
 19192  				}
 19193  			} else {
 19194  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19195  					return err
 19196  				}
 19197  			}
 19198  		default:
 19199  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19200  				return err
 19201  			}
 19202  		}
 19203  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19204  			return err
 19205  		}
 19206  	}
 19207  	if err := tp.ReadStructEnd(ctx); err != nil {
 19208  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19209  	}
 19210  	return nil
 19211  }
 19212  
 19213  func (p *RPushResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 19214  	p.Success = &IntResponse{}
 19215  	if err := p.Success.Read(ctx, tp); err != nil {
 19216  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 19217  	}
 19218  	return nil
 19219  }
 19220  
 19221  func (p *RPushResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 19222  	if err := tp.WriteStructBegin(ctx, "RPush_result"); err != nil {
 19223  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19224  	}
 19225  	if p != nil {
 19226  		if err := p.writeField0(ctx, tp); err != nil {
 19227  			return err
 19228  		}
 19229  	}
 19230  	if err := tp.WriteFieldStop(ctx); err != nil {
 19231  		return thrift.PrependError("write field stop error: ", err)
 19232  	}
 19233  	if err := tp.WriteStructEnd(ctx); err != nil {
 19234  		return thrift.PrependError("write struct stop error: ", err)
 19235  	}
 19236  	return nil
 19237  }
 19238  
 19239  func (p *RPushResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 19240  	if p.IsSetSuccess() {
 19241  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 19242  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 19243  		}
 19244  		if err := p.Success.Write(ctx, tp); err != nil {
 19245  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 19246  		}
 19247  		if err := tp.WriteFieldEnd(ctx); err != nil {
 19248  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 19249  		}
 19250  	}
 19251  	return err
 19252  }
 19253  
 19254  func (p *RPushResult) String() string {
 19255  	if p == nil {
 19256  		return "<nil>"
 19257  	}
 19258  	return fmt.Sprintf("RPushResult(%+v)", *p)
 19259  }
 19260  
 19261  // Attributes:
 19262  //  - Appid
 19263  //  - Key
 19264  //  - Value
 19265  type RPushByteArgs struct {
 19266  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 19267  	Key   string `thrift:"key,2" db:"key" json:"key"`
 19268  	Value []byte `thrift:"value,3" db:"value" json:"value"`
 19269  }
 19270  
 19271  func NewRPushByteArgs() *RPushByteArgs {
 19272  	return &RPushByteArgs{}
 19273  }
 19274  
 19275  func (p *RPushByteArgs) GetAppid() string {
 19276  	return p.Appid
 19277  }
 19278  
 19279  func (p *RPushByteArgs) GetKey() string {
 19280  	return p.Key
 19281  }
 19282  
 19283  func (p *RPushByteArgs) GetValue() []byte {
 19284  	return p.Value
 19285  }
 19286  func (p *RPushByteArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 19287  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19288  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19289  	}
 19290  
 19291  	for {
 19292  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19293  		if err != nil {
 19294  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19295  		}
 19296  		if fieldTypeId == thrift.STOP {
 19297  			break
 19298  		}
 19299  		switch fieldId {
 19300  		case 1:
 19301  			if fieldTypeId == thrift.STRING {
 19302  				if err := p.ReadField1(ctx, tp); err != nil {
 19303  					return err
 19304  				}
 19305  			} else {
 19306  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19307  					return err
 19308  				}
 19309  			}
 19310  		case 2:
 19311  			if fieldTypeId == thrift.STRING {
 19312  				if err := p.ReadField2(ctx, tp); err != nil {
 19313  					return err
 19314  				}
 19315  			} else {
 19316  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19317  					return err
 19318  				}
 19319  			}
 19320  		case 3:
 19321  			if fieldTypeId == thrift.STRING {
 19322  				if err := p.ReadField3(ctx, tp); err != nil {
 19323  					return err
 19324  				}
 19325  			} else {
 19326  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19327  					return err
 19328  				}
 19329  			}
 19330  		default:
 19331  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19332  				return err
 19333  			}
 19334  		}
 19335  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19336  			return err
 19337  		}
 19338  	}
 19339  	if err := tp.ReadStructEnd(ctx); err != nil {
 19340  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19341  	}
 19342  	return nil
 19343  }
 19344  
 19345  func (p *RPushByteArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 19346  	if v, err := tp.ReadString(ctx); err != nil {
 19347  		return thrift.PrependError("error reading field 1: ", err)
 19348  	} else {
 19349  		p.Appid = v
 19350  	}
 19351  	return nil
 19352  }
 19353  
 19354  func (p *RPushByteArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 19355  	if v, err := tp.ReadString(ctx); err != nil {
 19356  		return thrift.PrependError("error reading field 2: ", err)
 19357  	} else {
 19358  		p.Key = v
 19359  	}
 19360  	return nil
 19361  }
 19362  
 19363  func (p *RPushByteArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 19364  	if v, err := tp.ReadBinary(ctx); err != nil {
 19365  		return thrift.PrependError("error reading field 3: ", err)
 19366  	} else {
 19367  		p.Value = v
 19368  	}
 19369  	return nil
 19370  }
 19371  
 19372  func (p *RPushByteArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 19373  	if err := tp.WriteStructBegin(ctx, "RPushByte_args"); err != nil {
 19374  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19375  	}
 19376  	if p != nil {
 19377  		if err := p.writeField1(ctx, tp); err != nil {
 19378  			return err
 19379  		}
 19380  		if err := p.writeField2(ctx, tp); err != nil {
 19381  			return err
 19382  		}
 19383  		if err := p.writeField3(ctx, tp); err != nil {
 19384  			return err
 19385  		}
 19386  	}
 19387  	if err := tp.WriteFieldStop(ctx); err != nil {
 19388  		return thrift.PrependError("write field stop error: ", err)
 19389  	}
 19390  	if err := tp.WriteStructEnd(ctx); err != nil {
 19391  		return thrift.PrependError("write struct stop error: ", err)
 19392  	}
 19393  	return nil
 19394  }
 19395  
 19396  func (p *RPushByteArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 19397  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 19398  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 19399  	}
 19400  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 19401  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 19402  	}
 19403  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19404  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 19405  	}
 19406  	return err
 19407  }
 19408  
 19409  func (p *RPushByteArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 19410  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 19411  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 19412  	}
 19413  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 19414  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 19415  	}
 19416  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19417  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 19418  	}
 19419  	return err
 19420  }
 19421  
 19422  func (p *RPushByteArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 19423  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 3); err != nil {
 19424  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 19425  	}
 19426  	if err := tp.WriteBinary(ctx, p.Value); err != nil {
 19427  		return thrift.PrependError(fmt.Sprintf("%T.value (3) field write error: ", p), err)
 19428  	}
 19429  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19430  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 19431  	}
 19432  	return err
 19433  }
 19434  
 19435  func (p *RPushByteArgs) String() string {
 19436  	if p == nil {
 19437  		return "<nil>"
 19438  	}
 19439  	return fmt.Sprintf("RPushByteArgs(%+v)", *p)
 19440  }
 19441  
 19442  // Attributes:
 19443  //  - Success
 19444  type RPushByteResult struct {
 19445  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 19446  }
 19447  
 19448  func NewRPushByteResult() *RPushByteResult {
 19449  	return &RPushByteResult{}
 19450  }
 19451  
 19452  var RPushByteResult_Success_DEFAULT *IntResponse
 19453  
 19454  func (p *RPushByteResult) GetSuccess() *IntResponse {
 19455  	if !p.IsSetSuccess() {
 19456  		return RPushByteResult_Success_DEFAULT
 19457  	}
 19458  	return p.Success
 19459  }
 19460  func (p *RPushByteResult) IsSetSuccess() bool {
 19461  	return p.Success != nil
 19462  }
 19463  
 19464  func (p *RPushByteResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 19465  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19466  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19467  	}
 19468  
 19469  	for {
 19470  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19471  		if err != nil {
 19472  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19473  		}
 19474  		if fieldTypeId == thrift.STOP {
 19475  			break
 19476  		}
 19477  		switch fieldId {
 19478  		case 0:
 19479  			if fieldTypeId == thrift.STRUCT {
 19480  				if err := p.ReadField0(ctx, tp); err != nil {
 19481  					return err
 19482  				}
 19483  			} else {
 19484  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19485  					return err
 19486  				}
 19487  			}
 19488  		default:
 19489  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19490  				return err
 19491  			}
 19492  		}
 19493  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19494  			return err
 19495  		}
 19496  	}
 19497  	if err := tp.ReadStructEnd(ctx); err != nil {
 19498  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19499  	}
 19500  	return nil
 19501  }
 19502  
 19503  func (p *RPushByteResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 19504  	p.Success = &IntResponse{}
 19505  	if err := p.Success.Read(ctx, tp); err != nil {
 19506  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 19507  	}
 19508  	return nil
 19509  }
 19510  
 19511  func (p *RPushByteResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 19512  	if err := tp.WriteStructBegin(ctx, "RPushByte_result"); err != nil {
 19513  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19514  	}
 19515  	if p != nil {
 19516  		if err := p.writeField0(ctx, tp); err != nil {
 19517  			return err
 19518  		}
 19519  	}
 19520  	if err := tp.WriteFieldStop(ctx); err != nil {
 19521  		return thrift.PrependError("write field stop error: ", err)
 19522  	}
 19523  	if err := tp.WriteStructEnd(ctx); err != nil {
 19524  		return thrift.PrependError("write struct stop error: ", err)
 19525  	}
 19526  	return nil
 19527  }
 19528  
 19529  func (p *RPushByteResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 19530  	if p.IsSetSuccess() {
 19531  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 19532  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 19533  		}
 19534  		if err := p.Success.Write(ctx, tp); err != nil {
 19535  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 19536  		}
 19537  		if err := tp.WriteFieldEnd(ctx); err != nil {
 19538  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 19539  		}
 19540  	}
 19541  	return err
 19542  }
 19543  
 19544  func (p *RPushByteResult) String() string {
 19545  	if p == nil {
 19546  		return "<nil>"
 19547  	}
 19548  	return fmt.Sprintf("RPushByteResult(%+v)", *p)
 19549  }
 19550  
 19551  // Attributes:
 19552  //  - Appid
 19553  //  - Key
 19554  //  - Value
 19555  type MlPushArgs struct {
 19556  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 19557  	Key   string   `thrift:"key,2" db:"key" json:"key"`
 19558  	Value []string `thrift:"value,3" db:"value" json:"value"`
 19559  }
 19560  
 19561  func NewMLPushArgs() *MlPushArgs {
 19562  	return &MlPushArgs{}
 19563  }
 19564  
 19565  func (p *MlPushArgs) GetAppid() string {
 19566  	return p.Appid
 19567  }
 19568  
 19569  func (p *MlPushArgs) GetKey() string {
 19570  	return p.Key
 19571  }
 19572  
 19573  func (p *MlPushArgs) GetValue() []string {
 19574  	return p.Value
 19575  }
 19576  func (p *MlPushArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 19577  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19578  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19579  	}
 19580  
 19581  	for {
 19582  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19583  		if err != nil {
 19584  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19585  		}
 19586  		if fieldTypeId == thrift.STOP {
 19587  			break
 19588  		}
 19589  		switch fieldId {
 19590  		case 1:
 19591  			if fieldTypeId == thrift.STRING {
 19592  				if err := p.ReadField1(ctx, tp); err != nil {
 19593  					return err
 19594  				}
 19595  			} else {
 19596  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19597  					return err
 19598  				}
 19599  			}
 19600  		case 2:
 19601  			if fieldTypeId == thrift.STRING {
 19602  				if err := p.ReadField2(ctx, tp); err != nil {
 19603  					return err
 19604  				}
 19605  			} else {
 19606  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19607  					return err
 19608  				}
 19609  			}
 19610  		case 3:
 19611  			if fieldTypeId == thrift.LIST {
 19612  				if err := p.ReadField3(ctx, tp); err != nil {
 19613  					return err
 19614  				}
 19615  			} else {
 19616  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19617  					return err
 19618  				}
 19619  			}
 19620  		default:
 19621  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19622  				return err
 19623  			}
 19624  		}
 19625  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19626  			return err
 19627  		}
 19628  	}
 19629  	if err := tp.ReadStructEnd(ctx); err != nil {
 19630  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19631  	}
 19632  	return nil
 19633  }
 19634  
 19635  func (p *MlPushArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 19636  	if v, err := tp.ReadString(ctx); err != nil {
 19637  		return thrift.PrependError("error reading field 1: ", err)
 19638  	} else {
 19639  		p.Appid = v
 19640  	}
 19641  	return nil
 19642  }
 19643  
 19644  func (p *MlPushArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 19645  	if v, err := tp.ReadString(ctx); err != nil {
 19646  		return thrift.PrependError("error reading field 2: ", err)
 19647  	} else {
 19648  		p.Key = v
 19649  	}
 19650  	return nil
 19651  }
 19652  
 19653  func (p *MlPushArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 19654  	_, size, err := tp.ReadListBegin(ctx)
 19655  	if err != nil {
 19656  		return thrift.PrependError("error reading list begin: ", err)
 19657  	}
 19658  	tSlice := make([]string, 0, size)
 19659  	p.Value = tSlice
 19660  	for i := 0; i < size; i++ {
 19661  		var _elem197 string
 19662  		if v, err := tp.ReadString(ctx); err != nil {
 19663  			return thrift.PrependError("error reading field 0: ", err)
 19664  		} else {
 19665  			_elem197 = v
 19666  		}
 19667  		p.Value = append(p.Value, _elem197)
 19668  	}
 19669  	if err := tp.ReadListEnd(ctx); err != nil {
 19670  		return thrift.PrependError("error reading list end: ", err)
 19671  	}
 19672  	return nil
 19673  }
 19674  
 19675  func (p *MlPushArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 19676  	if err := tp.WriteStructBegin(ctx, "MLPush_args"); err != nil {
 19677  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19678  	}
 19679  	if p != nil {
 19680  		if err := p.writeField1(ctx, tp); err != nil {
 19681  			return err
 19682  		}
 19683  		if err := p.writeField2(ctx, tp); err != nil {
 19684  			return err
 19685  		}
 19686  		if err := p.writeField3(ctx, tp); err != nil {
 19687  			return err
 19688  		}
 19689  	}
 19690  	if err := tp.WriteFieldStop(ctx); err != nil {
 19691  		return thrift.PrependError("write field stop error: ", err)
 19692  	}
 19693  	if err := tp.WriteStructEnd(ctx); err != nil {
 19694  		return thrift.PrependError("write struct stop error: ", err)
 19695  	}
 19696  	return nil
 19697  }
 19698  
 19699  func (p *MlPushArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 19700  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 19701  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 19702  	}
 19703  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 19704  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 19705  	}
 19706  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19707  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 19708  	}
 19709  	return err
 19710  }
 19711  
 19712  func (p *MlPushArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 19713  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 19714  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 19715  	}
 19716  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 19717  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 19718  	}
 19719  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19720  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 19721  	}
 19722  	return err
 19723  }
 19724  
 19725  func (p *MlPushArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 19726  	if err := tp.WriteFieldBegin(ctx, "value", thrift.LIST, 3); err != nil {
 19727  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 19728  	}
 19729  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Value)); err != nil {
 19730  		return thrift.PrependError("error writing list begin: ", err)
 19731  	}
 19732  	for _, v := range p.Value {
 19733  		if err := tp.WriteString(ctx, string(v)); err != nil {
 19734  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 19735  		}
 19736  	}
 19737  	if err := tp.WriteListEnd(ctx); err != nil {
 19738  		return thrift.PrependError("error writing list end: ", err)
 19739  	}
 19740  	if err := tp.WriteFieldEnd(ctx); err != nil {
 19741  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 19742  	}
 19743  	return err
 19744  }
 19745  
 19746  func (p *MlPushArgs) String() string {
 19747  	if p == nil {
 19748  		return "<nil>"
 19749  	}
 19750  	return fmt.Sprintf("MlPushArgs(%+v)", *p)
 19751  }
 19752  
 19753  // Attributes:
 19754  //  - Success
 19755  type MlPushResult struct {
 19756  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 19757  }
 19758  
 19759  func NewMLPushResult() *MlPushResult {
 19760  	return &MlPushResult{}
 19761  }
 19762  
 19763  var MLPushResult_Success_DEFAULT *IntResponse
 19764  
 19765  func (p *MlPushResult) GetSuccess() *IntResponse {
 19766  	if !p.IsSetSuccess() {
 19767  		return MLPushResult_Success_DEFAULT
 19768  	}
 19769  	return p.Success
 19770  }
 19771  func (p *MlPushResult) IsSetSuccess() bool {
 19772  	return p.Success != nil
 19773  }
 19774  
 19775  func (p *MlPushResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 19776  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19777  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19778  	}
 19779  
 19780  	for {
 19781  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19782  		if err != nil {
 19783  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19784  		}
 19785  		if fieldTypeId == thrift.STOP {
 19786  			break
 19787  		}
 19788  		switch fieldId {
 19789  		case 0:
 19790  			if fieldTypeId == thrift.STRUCT {
 19791  				if err := p.ReadField0(ctx, tp); err != nil {
 19792  					return err
 19793  				}
 19794  			} else {
 19795  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19796  					return err
 19797  				}
 19798  			}
 19799  		default:
 19800  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19801  				return err
 19802  			}
 19803  		}
 19804  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19805  			return err
 19806  		}
 19807  	}
 19808  	if err := tp.ReadStructEnd(ctx); err != nil {
 19809  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19810  	}
 19811  	return nil
 19812  }
 19813  
 19814  func (p *MlPushResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 19815  	p.Success = &IntResponse{}
 19816  	if err := p.Success.Read(ctx, tp); err != nil {
 19817  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 19818  	}
 19819  	return nil
 19820  }
 19821  
 19822  func (p *MlPushResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 19823  	if err := tp.WriteStructBegin(ctx, "MLPush_result"); err != nil {
 19824  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 19825  	}
 19826  	if p != nil {
 19827  		if err := p.writeField0(ctx, tp); err != nil {
 19828  			return err
 19829  		}
 19830  	}
 19831  	if err := tp.WriteFieldStop(ctx); err != nil {
 19832  		return thrift.PrependError("write field stop error: ", err)
 19833  	}
 19834  	if err := tp.WriteStructEnd(ctx); err != nil {
 19835  		return thrift.PrependError("write struct stop error: ", err)
 19836  	}
 19837  	return nil
 19838  }
 19839  
 19840  func (p *MlPushResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 19841  	if p.IsSetSuccess() {
 19842  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 19843  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 19844  		}
 19845  		if err := p.Success.Write(ctx, tp); err != nil {
 19846  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 19847  		}
 19848  		if err := tp.WriteFieldEnd(ctx); err != nil {
 19849  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 19850  		}
 19851  	}
 19852  	return err
 19853  }
 19854  
 19855  func (p *MlPushResult) String() string {
 19856  	if p == nil {
 19857  		return "<nil>"
 19858  	}
 19859  	return fmt.Sprintf("MlPushResult(%+v)", *p)
 19860  }
 19861  
 19862  // Attributes:
 19863  //  - Appid
 19864  //  - Key
 19865  //  - Value
 19866  //  - TTL
 19867  type MlPushWithTTLArgs struct {
 19868  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 19869  	Key   string   `thrift:"key,2" db:"key" json:"key"`
 19870  	Value []string `thrift:"value,3" db:"value" json:"value"`
 19871  	TTL   int64    `thrift:"ttl,4" db:"ttl" json:"ttl"`
 19872  }
 19873  
 19874  func NewMLPushWithTTLArgs() *MlPushWithTTLArgs {
 19875  	return &MlPushWithTTLArgs{}
 19876  }
 19877  
 19878  func (p *MlPushWithTTLArgs) GetAppid() string {
 19879  	return p.Appid
 19880  }
 19881  
 19882  func (p *MlPushWithTTLArgs) GetKey() string {
 19883  	return p.Key
 19884  }
 19885  
 19886  func (p *MlPushWithTTLArgs) GetValue() []string {
 19887  	return p.Value
 19888  }
 19889  
 19890  func (p *MlPushWithTTLArgs) GetTTL() int64 {
 19891  	return p.TTL
 19892  }
 19893  func (p *MlPushWithTTLArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 19894  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 19895  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 19896  	}
 19897  
 19898  	for {
 19899  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 19900  		if err != nil {
 19901  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 19902  		}
 19903  		if fieldTypeId == thrift.STOP {
 19904  			break
 19905  		}
 19906  		switch fieldId {
 19907  		case 1:
 19908  			if fieldTypeId == thrift.STRING {
 19909  				if err := p.ReadField1(ctx, tp); err != nil {
 19910  					return err
 19911  				}
 19912  			} else {
 19913  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19914  					return err
 19915  				}
 19916  			}
 19917  		case 2:
 19918  			if fieldTypeId == thrift.STRING {
 19919  				if err := p.ReadField2(ctx, tp); err != nil {
 19920  					return err
 19921  				}
 19922  			} else {
 19923  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19924  					return err
 19925  				}
 19926  			}
 19927  		case 3:
 19928  			if fieldTypeId == thrift.LIST {
 19929  				if err := p.ReadField3(ctx, tp); err != nil {
 19930  					return err
 19931  				}
 19932  			} else {
 19933  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19934  					return err
 19935  				}
 19936  			}
 19937  		case 4:
 19938  			if fieldTypeId == thrift.I64 {
 19939  				if err := p.ReadField4(ctx, tp); err != nil {
 19940  					return err
 19941  				}
 19942  			} else {
 19943  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19944  					return err
 19945  				}
 19946  			}
 19947  		default:
 19948  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 19949  				return err
 19950  			}
 19951  		}
 19952  		if err := tp.ReadFieldEnd(ctx); err != nil {
 19953  			return err
 19954  		}
 19955  	}
 19956  	if err := tp.ReadStructEnd(ctx); err != nil {
 19957  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 19958  	}
 19959  	return nil
 19960  }
 19961  
 19962  func (p *MlPushWithTTLArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 19963  	if v, err := tp.ReadString(ctx); err != nil {
 19964  		return thrift.PrependError("error reading field 1: ", err)
 19965  	} else {
 19966  		p.Appid = v
 19967  	}
 19968  	return nil
 19969  }
 19970  
 19971  func (p *MlPushWithTTLArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 19972  	if v, err := tp.ReadString(ctx); err != nil {
 19973  		return thrift.PrependError("error reading field 2: ", err)
 19974  	} else {
 19975  		p.Key = v
 19976  	}
 19977  	return nil
 19978  }
 19979  
 19980  func (p *MlPushWithTTLArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 19981  	_, size, err := tp.ReadListBegin(ctx)
 19982  	if err != nil {
 19983  		return thrift.PrependError("error reading list begin: ", err)
 19984  	}
 19985  	tSlice := make([]string, 0, size)
 19986  	p.Value = tSlice
 19987  	for i := 0; i < size; i++ {
 19988  		var _elem198 string
 19989  		if v, err := tp.ReadString(ctx); err != nil {
 19990  			return thrift.PrependError("error reading field 0: ", err)
 19991  		} else {
 19992  			_elem198 = v
 19993  		}
 19994  		p.Value = append(p.Value, _elem198)
 19995  	}
 19996  	if err := tp.ReadListEnd(ctx); err != nil {
 19997  		return thrift.PrependError("error reading list end: ", err)
 19998  	}
 19999  	return nil
 20000  }
 20001  
 20002  func (p *MlPushWithTTLArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 20003  	if v, err := tp.ReadI64(ctx); err != nil {
 20004  		return thrift.PrependError("error reading field 4: ", err)
 20005  	} else {
 20006  		p.TTL = v
 20007  	}
 20008  	return nil
 20009  }
 20010  
 20011  func (p *MlPushWithTTLArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 20012  	if err := tp.WriteStructBegin(ctx, "MLPushWithTTL_args"); err != nil {
 20013  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20014  	}
 20015  	if p != nil {
 20016  		if err := p.writeField1(ctx, tp); err != nil {
 20017  			return err
 20018  		}
 20019  		if err := p.writeField2(ctx, tp); err != nil {
 20020  			return err
 20021  		}
 20022  		if err := p.writeField3(ctx, tp); err != nil {
 20023  			return err
 20024  		}
 20025  		if err := p.writeField4(ctx, tp); err != nil {
 20026  			return err
 20027  		}
 20028  	}
 20029  	if err := tp.WriteFieldStop(ctx); err != nil {
 20030  		return thrift.PrependError("write field stop error: ", err)
 20031  	}
 20032  	if err := tp.WriteStructEnd(ctx); err != nil {
 20033  		return thrift.PrependError("write struct stop error: ", err)
 20034  	}
 20035  	return nil
 20036  }
 20037  
 20038  func (p *MlPushWithTTLArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 20039  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 20040  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 20041  	}
 20042  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 20043  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 20044  	}
 20045  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20046  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 20047  	}
 20048  	return err
 20049  }
 20050  
 20051  func (p *MlPushWithTTLArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 20052  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 20053  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 20054  	}
 20055  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 20056  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 20057  	}
 20058  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20059  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 20060  	}
 20061  	return err
 20062  }
 20063  
 20064  func (p *MlPushWithTTLArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 20065  	if err := tp.WriteFieldBegin(ctx, "value", thrift.LIST, 3); err != nil {
 20066  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 20067  	}
 20068  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Value)); err != nil {
 20069  		return thrift.PrependError("error writing list begin: ", err)
 20070  	}
 20071  	for _, v := range p.Value {
 20072  		if err := tp.WriteString(ctx, string(v)); err != nil {
 20073  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 20074  		}
 20075  	}
 20076  	if err := tp.WriteListEnd(ctx); err != nil {
 20077  		return thrift.PrependError("error writing list end: ", err)
 20078  	}
 20079  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20080  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 20081  	}
 20082  	return err
 20083  }
 20084  
 20085  func (p *MlPushWithTTLArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 20086  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
 20087  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
 20088  	}
 20089  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
 20090  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
 20091  	}
 20092  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20093  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
 20094  	}
 20095  	return err
 20096  }
 20097  
 20098  func (p *MlPushWithTTLArgs) String() string {
 20099  	if p == nil {
 20100  		return "<nil>"
 20101  	}
 20102  	return fmt.Sprintf("MlPushWithTTLArgs(%+v)", *p)
 20103  }
 20104  
 20105  // Attributes:
 20106  //  - Success
 20107  type MlPushWithTTLResult struct {
 20108  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 20109  }
 20110  
 20111  func NewMLPushWithTTLResult() *MlPushWithTTLResult {
 20112  	return &MlPushWithTTLResult{}
 20113  }
 20114  
 20115  var MLPushWithTTLResult_Success_DEFAULT *IntResponse
 20116  
 20117  func (p *MlPushWithTTLResult) GetSuccess() *IntResponse {
 20118  	if !p.IsSetSuccess() {
 20119  		return MLPushWithTTLResult_Success_DEFAULT
 20120  	}
 20121  	return p.Success
 20122  }
 20123  func (p *MlPushWithTTLResult) IsSetSuccess() bool {
 20124  	return p.Success != nil
 20125  }
 20126  
 20127  func (p *MlPushWithTTLResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 20128  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20129  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20130  	}
 20131  
 20132  	for {
 20133  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20134  		if err != nil {
 20135  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20136  		}
 20137  		if fieldTypeId == thrift.STOP {
 20138  			break
 20139  		}
 20140  		switch fieldId {
 20141  		case 0:
 20142  			if fieldTypeId == thrift.STRUCT {
 20143  				if err := p.ReadField0(ctx, tp); err != nil {
 20144  					return err
 20145  				}
 20146  			} else {
 20147  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20148  					return err
 20149  				}
 20150  			}
 20151  		default:
 20152  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20153  				return err
 20154  			}
 20155  		}
 20156  		if err := tp.ReadFieldEnd(ctx); err != nil {
 20157  			return err
 20158  		}
 20159  	}
 20160  	if err := tp.ReadStructEnd(ctx); err != nil {
 20161  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 20162  	}
 20163  	return nil
 20164  }
 20165  
 20166  func (p *MlPushWithTTLResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 20167  	p.Success = &IntResponse{}
 20168  	if err := p.Success.Read(ctx, tp); err != nil {
 20169  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 20170  	}
 20171  	return nil
 20172  }
 20173  
 20174  func (p *MlPushWithTTLResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 20175  	if err := tp.WriteStructBegin(ctx, "MLPushWithTTL_result"); err != nil {
 20176  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20177  	}
 20178  	if p != nil {
 20179  		if err := p.writeField0(ctx, tp); err != nil {
 20180  			return err
 20181  		}
 20182  	}
 20183  	if err := tp.WriteFieldStop(ctx); err != nil {
 20184  		return thrift.PrependError("write field stop error: ", err)
 20185  	}
 20186  	if err := tp.WriteStructEnd(ctx); err != nil {
 20187  		return thrift.PrependError("write struct stop error: ", err)
 20188  	}
 20189  	return nil
 20190  }
 20191  
 20192  func (p *MlPushWithTTLResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 20193  	if p.IsSetSuccess() {
 20194  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 20195  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 20196  		}
 20197  		if err := p.Success.Write(ctx, tp); err != nil {
 20198  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 20199  		}
 20200  		if err := tp.WriteFieldEnd(ctx); err != nil {
 20201  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 20202  		}
 20203  	}
 20204  	return err
 20205  }
 20206  
 20207  func (p *MlPushWithTTLResult) String() string {
 20208  	if p == nil {
 20209  		return "<nil>"
 20210  	}
 20211  	return fmt.Sprintf("MlPushWithTTLResult(%+v)", *p)
 20212  }
 20213  
 20214  // Attributes:
 20215  //  - Appid
 20216  //  - Key
 20217  //  - Value
 20218  //  - TTL
 20219  type MlPushByteWithTTLArgs struct {
 20220  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 20221  	Key   string   `thrift:"key,2" db:"key" json:"key"`
 20222  	Value [][]byte `thrift:"value,3" db:"value" json:"value"`
 20223  	TTL   int64    `thrift:"ttl,4" db:"ttl" json:"ttl"`
 20224  }
 20225  
 20226  func NewMLPushByteWithTTLArgs() *MlPushByteWithTTLArgs {
 20227  	return &MlPushByteWithTTLArgs{}
 20228  }
 20229  
 20230  func (p *MlPushByteWithTTLArgs) GetAppid() string {
 20231  	return p.Appid
 20232  }
 20233  
 20234  func (p *MlPushByteWithTTLArgs) GetKey() string {
 20235  	return p.Key
 20236  }
 20237  
 20238  func (p *MlPushByteWithTTLArgs) GetValue() [][]byte {
 20239  	return p.Value
 20240  }
 20241  
 20242  func (p *MlPushByteWithTTLArgs) GetTTL() int64 {
 20243  	return p.TTL
 20244  }
 20245  func (p *MlPushByteWithTTLArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 20246  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20247  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20248  	}
 20249  
 20250  	for {
 20251  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20252  		if err != nil {
 20253  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20254  		}
 20255  		if fieldTypeId == thrift.STOP {
 20256  			break
 20257  		}
 20258  		switch fieldId {
 20259  		case 1:
 20260  			if fieldTypeId == thrift.STRING {
 20261  				if err := p.ReadField1(ctx, tp); err != nil {
 20262  					return err
 20263  				}
 20264  			} else {
 20265  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20266  					return err
 20267  				}
 20268  			}
 20269  		case 2:
 20270  			if fieldTypeId == thrift.STRING {
 20271  				if err := p.ReadField2(ctx, tp); err != nil {
 20272  					return err
 20273  				}
 20274  			} else {
 20275  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20276  					return err
 20277  				}
 20278  			}
 20279  		case 3:
 20280  			if fieldTypeId == thrift.LIST {
 20281  				if err := p.ReadField3(ctx, tp); err != nil {
 20282  					return err
 20283  				}
 20284  			} else {
 20285  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20286  					return err
 20287  				}
 20288  			}
 20289  		case 4:
 20290  			if fieldTypeId == thrift.I64 {
 20291  				if err := p.ReadField4(ctx, tp); err != nil {
 20292  					return err
 20293  				}
 20294  			} else {
 20295  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20296  					return err
 20297  				}
 20298  			}
 20299  		default:
 20300  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20301  				return err
 20302  			}
 20303  		}
 20304  		if err := tp.ReadFieldEnd(ctx); err != nil {
 20305  			return err
 20306  		}
 20307  	}
 20308  	if err := tp.ReadStructEnd(ctx); err != nil {
 20309  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 20310  	}
 20311  	return nil
 20312  }
 20313  
 20314  func (p *MlPushByteWithTTLArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 20315  	if v, err := tp.ReadString(ctx); err != nil {
 20316  		return thrift.PrependError("error reading field 1: ", err)
 20317  	} else {
 20318  		p.Appid = v
 20319  	}
 20320  	return nil
 20321  }
 20322  
 20323  func (p *MlPushByteWithTTLArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 20324  	if v, err := tp.ReadString(ctx); err != nil {
 20325  		return thrift.PrependError("error reading field 2: ", err)
 20326  	} else {
 20327  		p.Key = v
 20328  	}
 20329  	return nil
 20330  }
 20331  
 20332  func (p *MlPushByteWithTTLArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 20333  	_, size, err := tp.ReadListBegin(ctx)
 20334  	if err != nil {
 20335  		return thrift.PrependError("error reading list begin: ", err)
 20336  	}
 20337  	tSlice := make([][]byte, 0, size)
 20338  	p.Value = tSlice
 20339  	for i := 0; i < size; i++ {
 20340  		var _elem199 []byte
 20341  		if v, err := tp.ReadBinary(ctx); err != nil {
 20342  			return thrift.PrependError("error reading field 0: ", err)
 20343  		} else {
 20344  			_elem199 = v
 20345  		}
 20346  		p.Value = append(p.Value, _elem199)
 20347  	}
 20348  	if err := tp.ReadListEnd(ctx); err != nil {
 20349  		return thrift.PrependError("error reading list end: ", err)
 20350  	}
 20351  	return nil
 20352  }
 20353  
 20354  func (p *MlPushByteWithTTLArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 20355  	if v, err := tp.ReadI64(ctx); err != nil {
 20356  		return thrift.PrependError("error reading field 4: ", err)
 20357  	} else {
 20358  		p.TTL = v
 20359  	}
 20360  	return nil
 20361  }
 20362  
 20363  func (p *MlPushByteWithTTLArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 20364  	if err := tp.WriteStructBegin(ctx, "MLPushByteWithTTL_args"); err != nil {
 20365  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20366  	}
 20367  	if p != nil {
 20368  		if err := p.writeField1(ctx, tp); err != nil {
 20369  			return err
 20370  		}
 20371  		if err := p.writeField2(ctx, tp); err != nil {
 20372  			return err
 20373  		}
 20374  		if err := p.writeField3(ctx, tp); err != nil {
 20375  			return err
 20376  		}
 20377  		if err := p.writeField4(ctx, tp); err != nil {
 20378  			return err
 20379  		}
 20380  	}
 20381  	if err := tp.WriteFieldStop(ctx); err != nil {
 20382  		return thrift.PrependError("write field stop error: ", err)
 20383  	}
 20384  	if err := tp.WriteStructEnd(ctx); err != nil {
 20385  		return thrift.PrependError("write struct stop error: ", err)
 20386  	}
 20387  	return nil
 20388  }
 20389  
 20390  func (p *MlPushByteWithTTLArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 20391  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 20392  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 20393  	}
 20394  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 20395  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 20396  	}
 20397  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20398  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 20399  	}
 20400  	return err
 20401  }
 20402  
 20403  func (p *MlPushByteWithTTLArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 20404  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 20405  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 20406  	}
 20407  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 20408  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 20409  	}
 20410  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20411  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 20412  	}
 20413  	return err
 20414  }
 20415  
 20416  func (p *MlPushByteWithTTLArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 20417  	if err := tp.WriteFieldBegin(ctx, "value", thrift.LIST, 3); err != nil {
 20418  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 20419  	}
 20420  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Value)); err != nil {
 20421  		return thrift.PrependError("error writing list begin: ", err)
 20422  	}
 20423  	for _, v := range p.Value {
 20424  		if err := tp.WriteBinary(ctx, v); err != nil {
 20425  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 20426  		}
 20427  	}
 20428  	if err := tp.WriteListEnd(ctx); err != nil {
 20429  		return thrift.PrependError("error writing list end: ", err)
 20430  	}
 20431  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20432  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 20433  	}
 20434  	return err
 20435  }
 20436  
 20437  func (p *MlPushByteWithTTLArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 20438  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
 20439  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
 20440  	}
 20441  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
 20442  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
 20443  	}
 20444  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20445  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
 20446  	}
 20447  	return err
 20448  }
 20449  
 20450  func (p *MlPushByteWithTTLArgs) String() string {
 20451  	if p == nil {
 20452  		return "<nil>"
 20453  	}
 20454  	return fmt.Sprintf("MlPushByteWithTTLArgs(%+v)", *p)
 20455  }
 20456  
 20457  // Attributes:
 20458  //  - Success
 20459  type MlPushByteWithTTLResult struct {
 20460  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 20461  }
 20462  
 20463  func NewMLPushByteWithTTLResult() *MlPushByteWithTTLResult {
 20464  	return &MlPushByteWithTTLResult{}
 20465  }
 20466  
 20467  var MLPushByteWithTTLResult_Success_DEFAULT *IntResponse
 20468  
 20469  func (p *MlPushByteWithTTLResult) GetSuccess() *IntResponse {
 20470  	if !p.IsSetSuccess() {
 20471  		return MLPushByteWithTTLResult_Success_DEFAULT
 20472  	}
 20473  	return p.Success
 20474  }
 20475  func (p *MlPushByteWithTTLResult) IsSetSuccess() bool {
 20476  	return p.Success != nil
 20477  }
 20478  
 20479  func (p *MlPushByteWithTTLResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 20480  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20481  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20482  	}
 20483  
 20484  	for {
 20485  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20486  		if err != nil {
 20487  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20488  		}
 20489  		if fieldTypeId == thrift.STOP {
 20490  			break
 20491  		}
 20492  		switch fieldId {
 20493  		case 0:
 20494  			if fieldTypeId == thrift.STRUCT {
 20495  				if err := p.ReadField0(ctx, tp); err != nil {
 20496  					return err
 20497  				}
 20498  			} else {
 20499  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20500  					return err
 20501  				}
 20502  			}
 20503  		default:
 20504  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20505  				return err
 20506  			}
 20507  		}
 20508  		if err := tp.ReadFieldEnd(ctx); err != nil {
 20509  			return err
 20510  		}
 20511  	}
 20512  	if err := tp.ReadStructEnd(ctx); err != nil {
 20513  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 20514  	}
 20515  	return nil
 20516  }
 20517  
 20518  func (p *MlPushByteWithTTLResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 20519  	p.Success = &IntResponse{}
 20520  	if err := p.Success.Read(ctx, tp); err != nil {
 20521  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 20522  	}
 20523  	return nil
 20524  }
 20525  
 20526  func (p *MlPushByteWithTTLResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 20527  	if err := tp.WriteStructBegin(ctx, "MLPushByteWithTTL_result"); err != nil {
 20528  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20529  	}
 20530  	if p != nil {
 20531  		if err := p.writeField0(ctx, tp); err != nil {
 20532  			return err
 20533  		}
 20534  	}
 20535  	if err := tp.WriteFieldStop(ctx); err != nil {
 20536  		return thrift.PrependError("write field stop error: ", err)
 20537  	}
 20538  	if err := tp.WriteStructEnd(ctx); err != nil {
 20539  		return thrift.PrependError("write struct stop error: ", err)
 20540  	}
 20541  	return nil
 20542  }
 20543  
 20544  func (p *MlPushByteWithTTLResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 20545  	if p.IsSetSuccess() {
 20546  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 20547  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 20548  		}
 20549  		if err := p.Success.Write(ctx, tp); err != nil {
 20550  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 20551  		}
 20552  		if err := tp.WriteFieldEnd(ctx); err != nil {
 20553  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 20554  		}
 20555  	}
 20556  	return err
 20557  }
 20558  
 20559  func (p *MlPushByteWithTTLResult) String() string {
 20560  	if p == nil {
 20561  		return "<nil>"
 20562  	}
 20563  	return fmt.Sprintf("MlPushByteWithTTLResult(%+v)", *p)
 20564  }
 20565  
 20566  // Attributes:
 20567  //  - Appid
 20568  //  - Key
 20569  //  - Value
 20570  //  - TTL
 20571  type MrPushWithTTLArgs struct {
 20572  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 20573  	Key   string   `thrift:"key,2" db:"key" json:"key"`
 20574  	Value []string `thrift:"value,3" db:"value" json:"value"`
 20575  	TTL   int64    `thrift:"ttl,4" db:"ttl" json:"ttl"`
 20576  }
 20577  
 20578  func NewMRPushWithTTLArgs() *MrPushWithTTLArgs {
 20579  	return &MrPushWithTTLArgs{}
 20580  }
 20581  
 20582  func (p *MrPushWithTTLArgs) GetAppid() string {
 20583  	return p.Appid
 20584  }
 20585  
 20586  func (p *MrPushWithTTLArgs) GetKey() string {
 20587  	return p.Key
 20588  }
 20589  
 20590  func (p *MrPushWithTTLArgs) GetValue() []string {
 20591  	return p.Value
 20592  }
 20593  
 20594  func (p *MrPushWithTTLArgs) GetTTL() int64 {
 20595  	return p.TTL
 20596  }
 20597  func (p *MrPushWithTTLArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 20598  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20599  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20600  	}
 20601  
 20602  	for {
 20603  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20604  		if err != nil {
 20605  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20606  		}
 20607  		if fieldTypeId == thrift.STOP {
 20608  			break
 20609  		}
 20610  		switch fieldId {
 20611  		case 1:
 20612  			if fieldTypeId == thrift.STRING {
 20613  				if err := p.ReadField1(ctx, tp); err != nil {
 20614  					return err
 20615  				}
 20616  			} else {
 20617  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20618  					return err
 20619  				}
 20620  			}
 20621  		case 2:
 20622  			if fieldTypeId == thrift.STRING {
 20623  				if err := p.ReadField2(ctx, tp); err != nil {
 20624  					return err
 20625  				}
 20626  			} else {
 20627  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20628  					return err
 20629  				}
 20630  			}
 20631  		case 3:
 20632  			if fieldTypeId == thrift.LIST {
 20633  				if err := p.ReadField3(ctx, tp); err != nil {
 20634  					return err
 20635  				}
 20636  			} else {
 20637  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20638  					return err
 20639  				}
 20640  			}
 20641  		case 4:
 20642  			if fieldTypeId == thrift.I64 {
 20643  				if err := p.ReadField4(ctx, tp); err != nil {
 20644  					return err
 20645  				}
 20646  			} else {
 20647  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20648  					return err
 20649  				}
 20650  			}
 20651  		default:
 20652  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20653  				return err
 20654  			}
 20655  		}
 20656  		if err := tp.ReadFieldEnd(ctx); err != nil {
 20657  			return err
 20658  		}
 20659  	}
 20660  	if err := tp.ReadStructEnd(ctx); err != nil {
 20661  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 20662  	}
 20663  	return nil
 20664  }
 20665  
 20666  func (p *MrPushWithTTLArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 20667  	if v, err := tp.ReadString(ctx); err != nil {
 20668  		return thrift.PrependError("error reading field 1: ", err)
 20669  	} else {
 20670  		p.Appid = v
 20671  	}
 20672  	return nil
 20673  }
 20674  
 20675  func (p *MrPushWithTTLArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 20676  	if v, err := tp.ReadString(ctx); err != nil {
 20677  		return thrift.PrependError("error reading field 2: ", err)
 20678  	} else {
 20679  		p.Key = v
 20680  	}
 20681  	return nil
 20682  }
 20683  
 20684  func (p *MrPushWithTTLArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 20685  	_, size, err := tp.ReadListBegin(ctx)
 20686  	if err != nil {
 20687  		return thrift.PrependError("error reading list begin: ", err)
 20688  	}
 20689  	tSlice := make([]string, 0, size)
 20690  	p.Value = tSlice
 20691  	for i := 0; i < size; i++ {
 20692  		var _elem200 string
 20693  		if v, err := tp.ReadString(ctx); err != nil {
 20694  			return thrift.PrependError("error reading field 0: ", err)
 20695  		} else {
 20696  			_elem200 = v
 20697  		}
 20698  		p.Value = append(p.Value, _elem200)
 20699  	}
 20700  	if err := tp.ReadListEnd(ctx); err != nil {
 20701  		return thrift.PrependError("error reading list end: ", err)
 20702  	}
 20703  	return nil
 20704  }
 20705  
 20706  func (p *MrPushWithTTLArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 20707  	if v, err := tp.ReadI64(ctx); err != nil {
 20708  		return thrift.PrependError("error reading field 4: ", err)
 20709  	} else {
 20710  		p.TTL = v
 20711  	}
 20712  	return nil
 20713  }
 20714  
 20715  func (p *MrPushWithTTLArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 20716  	if err := tp.WriteStructBegin(ctx, "MRPushWithTTL_args"); err != nil {
 20717  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20718  	}
 20719  	if p != nil {
 20720  		if err := p.writeField1(ctx, tp); err != nil {
 20721  			return err
 20722  		}
 20723  		if err := p.writeField2(ctx, tp); err != nil {
 20724  			return err
 20725  		}
 20726  		if err := p.writeField3(ctx, tp); err != nil {
 20727  			return err
 20728  		}
 20729  		if err := p.writeField4(ctx, tp); err != nil {
 20730  			return err
 20731  		}
 20732  	}
 20733  	if err := tp.WriteFieldStop(ctx); err != nil {
 20734  		return thrift.PrependError("write field stop error: ", err)
 20735  	}
 20736  	if err := tp.WriteStructEnd(ctx); err != nil {
 20737  		return thrift.PrependError("write struct stop error: ", err)
 20738  	}
 20739  	return nil
 20740  }
 20741  
 20742  func (p *MrPushWithTTLArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 20743  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 20744  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 20745  	}
 20746  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 20747  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 20748  	}
 20749  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20750  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 20751  	}
 20752  	return err
 20753  }
 20754  
 20755  func (p *MrPushWithTTLArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 20756  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 20757  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 20758  	}
 20759  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 20760  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 20761  	}
 20762  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20763  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 20764  	}
 20765  	return err
 20766  }
 20767  
 20768  func (p *MrPushWithTTLArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 20769  	if err := tp.WriteFieldBegin(ctx, "value", thrift.LIST, 3); err != nil {
 20770  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 20771  	}
 20772  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Value)); err != nil {
 20773  		return thrift.PrependError("error writing list begin: ", err)
 20774  	}
 20775  	for _, v := range p.Value {
 20776  		if err := tp.WriteString(ctx, string(v)); err != nil {
 20777  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 20778  		}
 20779  	}
 20780  	if err := tp.WriteListEnd(ctx); err != nil {
 20781  		return thrift.PrependError("error writing list end: ", err)
 20782  	}
 20783  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20784  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 20785  	}
 20786  	return err
 20787  }
 20788  
 20789  func (p *MrPushWithTTLArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 20790  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
 20791  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
 20792  	}
 20793  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
 20794  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
 20795  	}
 20796  	if err := tp.WriteFieldEnd(ctx); err != nil {
 20797  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
 20798  	}
 20799  	return err
 20800  }
 20801  
 20802  func (p *MrPushWithTTLArgs) String() string {
 20803  	if p == nil {
 20804  		return "<nil>"
 20805  	}
 20806  	return fmt.Sprintf("MrPushWithTTLArgs(%+v)", *p)
 20807  }
 20808  
 20809  // Attributes:
 20810  //  - Success
 20811  type MrPushWithTTLResult struct {
 20812  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 20813  }
 20814  
 20815  func NewMRPushWithTTLResult() *MrPushWithTTLResult {
 20816  	return &MrPushWithTTLResult{}
 20817  }
 20818  
 20819  var MRPushWithTTLResult_Success_DEFAULT *IntResponse
 20820  
 20821  func (p *MrPushWithTTLResult) GetSuccess() *IntResponse {
 20822  	if !p.IsSetSuccess() {
 20823  		return MRPushWithTTLResult_Success_DEFAULT
 20824  	}
 20825  	return p.Success
 20826  }
 20827  func (p *MrPushWithTTLResult) IsSetSuccess() bool {
 20828  	return p.Success != nil
 20829  }
 20830  
 20831  func (p *MrPushWithTTLResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 20832  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20833  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20834  	}
 20835  
 20836  	for {
 20837  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20838  		if err != nil {
 20839  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20840  		}
 20841  		if fieldTypeId == thrift.STOP {
 20842  			break
 20843  		}
 20844  		switch fieldId {
 20845  		case 0:
 20846  			if fieldTypeId == thrift.STRUCT {
 20847  				if err := p.ReadField0(ctx, tp); err != nil {
 20848  					return err
 20849  				}
 20850  			} else {
 20851  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20852  					return err
 20853  				}
 20854  			}
 20855  		default:
 20856  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20857  				return err
 20858  			}
 20859  		}
 20860  		if err := tp.ReadFieldEnd(ctx); err != nil {
 20861  			return err
 20862  		}
 20863  	}
 20864  	if err := tp.ReadStructEnd(ctx); err != nil {
 20865  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 20866  	}
 20867  	return nil
 20868  }
 20869  
 20870  func (p *MrPushWithTTLResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 20871  	p.Success = &IntResponse{}
 20872  	if err := p.Success.Read(ctx, tp); err != nil {
 20873  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 20874  	}
 20875  	return nil
 20876  }
 20877  
 20878  func (p *MrPushWithTTLResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 20879  	if err := tp.WriteStructBegin(ctx, "MRPushWithTTL_result"); err != nil {
 20880  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 20881  	}
 20882  	if p != nil {
 20883  		if err := p.writeField0(ctx, tp); err != nil {
 20884  			return err
 20885  		}
 20886  	}
 20887  	if err := tp.WriteFieldStop(ctx); err != nil {
 20888  		return thrift.PrependError("write field stop error: ", err)
 20889  	}
 20890  	if err := tp.WriteStructEnd(ctx); err != nil {
 20891  		return thrift.PrependError("write struct stop error: ", err)
 20892  	}
 20893  	return nil
 20894  }
 20895  
 20896  func (p *MrPushWithTTLResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 20897  	if p.IsSetSuccess() {
 20898  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 20899  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 20900  		}
 20901  		if err := p.Success.Write(ctx, tp); err != nil {
 20902  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 20903  		}
 20904  		if err := tp.WriteFieldEnd(ctx); err != nil {
 20905  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 20906  		}
 20907  	}
 20908  	return err
 20909  }
 20910  
 20911  func (p *MrPushWithTTLResult) String() string {
 20912  	if p == nil {
 20913  		return "<nil>"
 20914  	}
 20915  	return fmt.Sprintf("MrPushWithTTLResult(%+v)", *p)
 20916  }
 20917  
 20918  // Attributes:
 20919  //  - Appid
 20920  //  - Key
 20921  //  - Value
 20922  //  - TTL
 20923  type MrPushByteWithTTLArgs struct {
 20924  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 20925  	Key   string   `thrift:"key,2" db:"key" json:"key"`
 20926  	Value [][]byte `thrift:"value,3" db:"value" json:"value"`
 20927  	TTL   int64    `thrift:"ttl,4" db:"ttl" json:"ttl"`
 20928  }
 20929  
 20930  func NewMRPushByteWithTTLArgs() *MrPushByteWithTTLArgs {
 20931  	return &MrPushByteWithTTLArgs{}
 20932  }
 20933  
 20934  func (p *MrPushByteWithTTLArgs) GetAppid() string {
 20935  	return p.Appid
 20936  }
 20937  
 20938  func (p *MrPushByteWithTTLArgs) GetKey() string {
 20939  	return p.Key
 20940  }
 20941  
 20942  func (p *MrPushByteWithTTLArgs) GetValue() [][]byte {
 20943  	return p.Value
 20944  }
 20945  
 20946  func (p *MrPushByteWithTTLArgs) GetTTL() int64 {
 20947  	return p.TTL
 20948  }
 20949  func (p *MrPushByteWithTTLArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 20950  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 20951  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 20952  	}
 20953  
 20954  	for {
 20955  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 20956  		if err != nil {
 20957  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 20958  		}
 20959  		if fieldTypeId == thrift.STOP {
 20960  			break
 20961  		}
 20962  		switch fieldId {
 20963  		case 1:
 20964  			if fieldTypeId == thrift.STRING {
 20965  				if err := p.ReadField1(ctx, tp); err != nil {
 20966  					return err
 20967  				}
 20968  			} else {
 20969  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20970  					return err
 20971  				}
 20972  			}
 20973  		case 2:
 20974  			if fieldTypeId == thrift.STRING {
 20975  				if err := p.ReadField2(ctx, tp); err != nil {
 20976  					return err
 20977  				}
 20978  			} else {
 20979  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20980  					return err
 20981  				}
 20982  			}
 20983  		case 3:
 20984  			if fieldTypeId == thrift.LIST {
 20985  				if err := p.ReadField3(ctx, tp); err != nil {
 20986  					return err
 20987  				}
 20988  			} else {
 20989  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 20990  					return err
 20991  				}
 20992  			}
 20993  		case 4:
 20994  			if fieldTypeId == thrift.I64 {
 20995  				if err := p.ReadField4(ctx, tp); err != nil {
 20996  					return err
 20997  				}
 20998  			} else {
 20999  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21000  					return err
 21001  				}
 21002  			}
 21003  		default:
 21004  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21005  				return err
 21006  			}
 21007  		}
 21008  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21009  			return err
 21010  		}
 21011  	}
 21012  	if err := tp.ReadStructEnd(ctx); err != nil {
 21013  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21014  	}
 21015  	return nil
 21016  }
 21017  
 21018  func (p *MrPushByteWithTTLArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 21019  	if v, err := tp.ReadString(ctx); err != nil {
 21020  		return thrift.PrependError("error reading field 1: ", err)
 21021  	} else {
 21022  		p.Appid = v
 21023  	}
 21024  	return nil
 21025  }
 21026  
 21027  func (p *MrPushByteWithTTLArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 21028  	if v, err := tp.ReadString(ctx); err != nil {
 21029  		return thrift.PrependError("error reading field 2: ", err)
 21030  	} else {
 21031  		p.Key = v
 21032  	}
 21033  	return nil
 21034  }
 21035  
 21036  func (p *MrPushByteWithTTLArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 21037  	_, size, err := tp.ReadListBegin(ctx)
 21038  	if err != nil {
 21039  		return thrift.PrependError("error reading list begin: ", err)
 21040  	}
 21041  	tSlice := make([][]byte, 0, size)
 21042  	p.Value = tSlice
 21043  	for i := 0; i < size; i++ {
 21044  		var _elem201 []byte
 21045  		if v, err := tp.ReadBinary(ctx); err != nil {
 21046  			return thrift.PrependError("error reading field 0: ", err)
 21047  		} else {
 21048  			_elem201 = v
 21049  		}
 21050  		p.Value = append(p.Value, _elem201)
 21051  	}
 21052  	if err := tp.ReadListEnd(ctx); err != nil {
 21053  		return thrift.PrependError("error reading list end: ", err)
 21054  	}
 21055  	return nil
 21056  }
 21057  
 21058  func (p *MrPushByteWithTTLArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 21059  	if v, err := tp.ReadI64(ctx); err != nil {
 21060  		return thrift.PrependError("error reading field 4: ", err)
 21061  	} else {
 21062  		p.TTL = v
 21063  	}
 21064  	return nil
 21065  }
 21066  
 21067  func (p *MrPushByteWithTTLArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 21068  	if err := tp.WriteStructBegin(ctx, "MRPushByteWithTTL_args"); err != nil {
 21069  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21070  	}
 21071  	if p != nil {
 21072  		if err := p.writeField1(ctx, tp); err != nil {
 21073  			return err
 21074  		}
 21075  		if err := p.writeField2(ctx, tp); err != nil {
 21076  			return err
 21077  		}
 21078  		if err := p.writeField3(ctx, tp); err != nil {
 21079  			return err
 21080  		}
 21081  		if err := p.writeField4(ctx, tp); err != nil {
 21082  			return err
 21083  		}
 21084  	}
 21085  	if err := tp.WriteFieldStop(ctx); err != nil {
 21086  		return thrift.PrependError("write field stop error: ", err)
 21087  	}
 21088  	if err := tp.WriteStructEnd(ctx); err != nil {
 21089  		return thrift.PrependError("write struct stop error: ", err)
 21090  	}
 21091  	return nil
 21092  }
 21093  
 21094  func (p *MrPushByteWithTTLArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 21095  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 21096  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 21097  	}
 21098  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 21099  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 21100  	}
 21101  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21102  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 21103  	}
 21104  	return err
 21105  }
 21106  
 21107  func (p *MrPushByteWithTTLArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 21108  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 21109  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 21110  	}
 21111  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 21112  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 21113  	}
 21114  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21115  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 21116  	}
 21117  	return err
 21118  }
 21119  
 21120  func (p *MrPushByteWithTTLArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 21121  	if err := tp.WriteFieldBegin(ctx, "value", thrift.LIST, 3); err != nil {
 21122  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:value: ", p), err)
 21123  	}
 21124  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Value)); err != nil {
 21125  		return thrift.PrependError("error writing list begin: ", err)
 21126  	}
 21127  	for _, v := range p.Value {
 21128  		if err := tp.WriteBinary(ctx, v); err != nil {
 21129  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 21130  		}
 21131  	}
 21132  	if err := tp.WriteListEnd(ctx); err != nil {
 21133  		return thrift.PrependError("error writing list end: ", err)
 21134  	}
 21135  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21136  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:value: ", p), err)
 21137  	}
 21138  	return err
 21139  }
 21140  
 21141  func (p *MrPushByteWithTTLArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 21142  	if err := tp.WriteFieldBegin(ctx, "ttl", thrift.I64, 4); err != nil {
 21143  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ttl: ", p), err)
 21144  	}
 21145  	if err := tp.WriteI64(ctx, int64(p.TTL)); err != nil {
 21146  		return thrift.PrependError(fmt.Sprintf("%T.ttl (4) field write error: ", p), err)
 21147  	}
 21148  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21149  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ttl: ", p), err)
 21150  	}
 21151  	return err
 21152  }
 21153  
 21154  func (p *MrPushByteWithTTLArgs) String() string {
 21155  	if p == nil {
 21156  		return "<nil>"
 21157  	}
 21158  	return fmt.Sprintf("MrPushByteWithTTLArgs(%+v)", *p)
 21159  }
 21160  
 21161  // Attributes:
 21162  //  - Success
 21163  type MrPushByteWithTTLResult struct {
 21164  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 21165  }
 21166  
 21167  func NewMRPushByteWithTTLResult() *MrPushByteWithTTLResult {
 21168  	return &MrPushByteWithTTLResult{}
 21169  }
 21170  
 21171  var MRPushByteWithTTLResult_Success_DEFAULT *IntResponse
 21172  
 21173  func (p *MrPushByteWithTTLResult) GetSuccess() *IntResponse {
 21174  	if !p.IsSetSuccess() {
 21175  		return MRPushByteWithTTLResult_Success_DEFAULT
 21176  	}
 21177  	return p.Success
 21178  }
 21179  func (p *MrPushByteWithTTLResult) IsSetSuccess() bool {
 21180  	return p.Success != nil
 21181  }
 21182  
 21183  func (p *MrPushByteWithTTLResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 21184  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21185  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21186  	}
 21187  
 21188  	for {
 21189  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21190  		if err != nil {
 21191  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21192  		}
 21193  		if fieldTypeId == thrift.STOP {
 21194  			break
 21195  		}
 21196  		switch fieldId {
 21197  		case 0:
 21198  			if fieldTypeId == thrift.STRUCT {
 21199  				if err := p.ReadField0(ctx, tp); err != nil {
 21200  					return err
 21201  				}
 21202  			} else {
 21203  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21204  					return err
 21205  				}
 21206  			}
 21207  		default:
 21208  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21209  				return err
 21210  			}
 21211  		}
 21212  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21213  			return err
 21214  		}
 21215  	}
 21216  	if err := tp.ReadStructEnd(ctx); err != nil {
 21217  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21218  	}
 21219  	return nil
 21220  }
 21221  
 21222  func (p *MrPushByteWithTTLResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 21223  	p.Success = &IntResponse{}
 21224  	if err := p.Success.Read(ctx, tp); err != nil {
 21225  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 21226  	}
 21227  	return nil
 21228  }
 21229  
 21230  func (p *MrPushByteWithTTLResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 21231  	if err := tp.WriteStructBegin(ctx, "MRPushByteWithTTL_result"); err != nil {
 21232  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21233  	}
 21234  	if p != nil {
 21235  		if err := p.writeField0(ctx, tp); err != nil {
 21236  			return err
 21237  		}
 21238  	}
 21239  	if err := tp.WriteFieldStop(ctx); err != nil {
 21240  		return thrift.PrependError("write field stop error: ", err)
 21241  	}
 21242  	if err := tp.WriteStructEnd(ctx); err != nil {
 21243  		return thrift.PrependError("write struct stop error: ", err)
 21244  	}
 21245  	return nil
 21246  }
 21247  
 21248  func (p *MrPushByteWithTTLResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 21249  	if p.IsSetSuccess() {
 21250  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 21251  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 21252  		}
 21253  		if err := p.Success.Write(ctx, tp); err != nil {
 21254  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 21255  		}
 21256  		if err := tp.WriteFieldEnd(ctx); err != nil {
 21257  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 21258  		}
 21259  	}
 21260  	return err
 21261  }
 21262  
 21263  func (p *MrPushByteWithTTLResult) String() string {
 21264  	if p == nil {
 21265  		return "<nil>"
 21266  	}
 21267  	return fmt.Sprintf("MrPushByteWithTTLResult(%+v)", *p)
 21268  }
 21269  
 21270  // Attributes:
 21271  //  - Appid
 21272  //  - Key
 21273  type ProxyLPopArgs struct {
 21274  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 21275  	Key   string `thrift:"key,2" db:"key" json:"key"`
 21276  }
 21277  
 21278  func NewLPopArgs() *ProxyLPopArgs {
 21279  	return &ProxyLPopArgs{}
 21280  }
 21281  
 21282  func (p *ProxyLPopArgs) GetAppid() string {
 21283  	return p.Appid
 21284  }
 21285  
 21286  func (p *ProxyLPopArgs) GetKey() string {
 21287  	return p.Key
 21288  }
 21289  func (p *ProxyLPopArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 21290  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21291  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21292  	}
 21293  
 21294  	for {
 21295  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21296  		if err != nil {
 21297  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21298  		}
 21299  		if fieldTypeId == thrift.STOP {
 21300  			break
 21301  		}
 21302  		switch fieldId {
 21303  		case 1:
 21304  			if fieldTypeId == thrift.STRING {
 21305  				if err := p.ReadField1(ctx, tp); err != nil {
 21306  					return err
 21307  				}
 21308  			} else {
 21309  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21310  					return err
 21311  				}
 21312  			}
 21313  		case 2:
 21314  			if fieldTypeId == thrift.STRING {
 21315  				if err := p.ReadField2(ctx, tp); err != nil {
 21316  					return err
 21317  				}
 21318  			} else {
 21319  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21320  					return err
 21321  				}
 21322  			}
 21323  		default:
 21324  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21325  				return err
 21326  			}
 21327  		}
 21328  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21329  			return err
 21330  		}
 21331  	}
 21332  	if err := tp.ReadStructEnd(ctx); err != nil {
 21333  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21334  	}
 21335  	return nil
 21336  }
 21337  
 21338  func (p *ProxyLPopArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 21339  	if v, err := tp.ReadString(ctx); err != nil {
 21340  		return thrift.PrependError("error reading field 1: ", err)
 21341  	} else {
 21342  		p.Appid = v
 21343  	}
 21344  	return nil
 21345  }
 21346  
 21347  func (p *ProxyLPopArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 21348  	if v, err := tp.ReadString(ctx); err != nil {
 21349  		return thrift.PrependError("error reading field 2: ", err)
 21350  	} else {
 21351  		p.Key = v
 21352  	}
 21353  	return nil
 21354  }
 21355  
 21356  func (p *ProxyLPopArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 21357  	if err := tp.WriteStructBegin(ctx, "LPop_args"); err != nil {
 21358  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21359  	}
 21360  	if p != nil {
 21361  		if err := p.writeField1(ctx, tp); err != nil {
 21362  			return err
 21363  		}
 21364  		if err := p.writeField2(ctx, tp); err != nil {
 21365  			return err
 21366  		}
 21367  	}
 21368  	if err := tp.WriteFieldStop(ctx); err != nil {
 21369  		return thrift.PrependError("write field stop error: ", err)
 21370  	}
 21371  	if err := tp.WriteStructEnd(ctx); err != nil {
 21372  		return thrift.PrependError("write struct stop error: ", err)
 21373  	}
 21374  	return nil
 21375  }
 21376  
 21377  func (p *ProxyLPopArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 21378  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 21379  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 21380  	}
 21381  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 21382  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 21383  	}
 21384  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21385  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 21386  	}
 21387  	return err
 21388  }
 21389  
 21390  func (p *ProxyLPopArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 21391  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 21392  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 21393  	}
 21394  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 21395  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 21396  	}
 21397  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21398  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 21399  	}
 21400  	return err
 21401  }
 21402  
 21403  func (p *ProxyLPopArgs) String() string {
 21404  	if p == nil {
 21405  		return "<nil>"
 21406  	}
 21407  	return fmt.Sprintf("ProxyLPopArgs(%+v)", *p)
 21408  }
 21409  
 21410  // Attributes:
 21411  //  - Success
 21412  type LPopResult struct {
 21413  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 21414  }
 21415  
 21416  func NewLPopResult() *LPopResult {
 21417  	return &LPopResult{}
 21418  }
 21419  
 21420  var LPopResult_Success_DEFAULT *Response
 21421  
 21422  func (p *LPopResult) GetSuccess() *Response {
 21423  	if !p.IsSetSuccess() {
 21424  		return LPopResult_Success_DEFAULT
 21425  	}
 21426  	return p.Success
 21427  }
 21428  func (p *LPopResult) IsSetSuccess() bool {
 21429  	return p.Success != nil
 21430  }
 21431  
 21432  func (p *LPopResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 21433  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21434  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21435  	}
 21436  
 21437  	for {
 21438  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21439  		if err != nil {
 21440  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21441  		}
 21442  		if fieldTypeId == thrift.STOP {
 21443  			break
 21444  		}
 21445  		switch fieldId {
 21446  		case 0:
 21447  			if fieldTypeId == thrift.STRUCT {
 21448  				if err := p.ReadField0(ctx, tp); err != nil {
 21449  					return err
 21450  				}
 21451  			} else {
 21452  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21453  					return err
 21454  				}
 21455  			}
 21456  		default:
 21457  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21458  				return err
 21459  			}
 21460  		}
 21461  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21462  			return err
 21463  		}
 21464  	}
 21465  	if err := tp.ReadStructEnd(ctx); err != nil {
 21466  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21467  	}
 21468  	return nil
 21469  }
 21470  
 21471  func (p *LPopResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 21472  	p.Success = &Response{}
 21473  	if err := p.Success.Read(ctx, tp); err != nil {
 21474  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 21475  	}
 21476  	return nil
 21477  }
 21478  
 21479  func (p *LPopResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 21480  	if err := tp.WriteStructBegin(ctx, "LPop_result"); err != nil {
 21481  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21482  	}
 21483  	if p != nil {
 21484  		if err := p.writeField0(ctx, tp); err != nil {
 21485  			return err
 21486  		}
 21487  	}
 21488  	if err := tp.WriteFieldStop(ctx); err != nil {
 21489  		return thrift.PrependError("write field stop error: ", err)
 21490  	}
 21491  	if err := tp.WriteStructEnd(ctx); err != nil {
 21492  		return thrift.PrependError("write struct stop error: ", err)
 21493  	}
 21494  	return nil
 21495  }
 21496  
 21497  func (p *LPopResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 21498  	if p.IsSetSuccess() {
 21499  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 21500  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 21501  		}
 21502  		if err := p.Success.Write(ctx, tp); err != nil {
 21503  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 21504  		}
 21505  		if err := tp.WriteFieldEnd(ctx); err != nil {
 21506  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 21507  		}
 21508  	}
 21509  	return err
 21510  }
 21511  
 21512  func (p *LPopResult) String() string {
 21513  	if p == nil {
 21514  		return "<nil>"
 21515  	}
 21516  	return fmt.Sprintf("LPopResult(%+v)", *p)
 21517  }
 21518  
 21519  // Attributes:
 21520  //  - Appid
 21521  //  - Key
 21522  type LPopByteArgs struct {
 21523  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 21524  	Key   string `thrift:"key,2" db:"key" json:"key"`
 21525  }
 21526  
 21527  func NewLPopByteArgs() *LPopByteArgs {
 21528  	return &LPopByteArgs{}
 21529  }
 21530  
 21531  func (p *LPopByteArgs) GetAppid() string {
 21532  	return p.Appid
 21533  }
 21534  
 21535  func (p *LPopByteArgs) GetKey() string {
 21536  	return p.Key
 21537  }
 21538  func (p *LPopByteArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 21539  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21540  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21541  	}
 21542  
 21543  	for {
 21544  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21545  		if err != nil {
 21546  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21547  		}
 21548  		if fieldTypeId == thrift.STOP {
 21549  			break
 21550  		}
 21551  		switch fieldId {
 21552  		case 1:
 21553  			if fieldTypeId == thrift.STRING {
 21554  				if err := p.ReadField1(ctx, tp); err != nil {
 21555  					return err
 21556  				}
 21557  			} else {
 21558  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21559  					return err
 21560  				}
 21561  			}
 21562  		case 2:
 21563  			if fieldTypeId == thrift.STRING {
 21564  				if err := p.ReadField2(ctx, tp); err != nil {
 21565  					return err
 21566  				}
 21567  			} else {
 21568  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21569  					return err
 21570  				}
 21571  			}
 21572  		default:
 21573  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21574  				return err
 21575  			}
 21576  		}
 21577  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21578  			return err
 21579  		}
 21580  	}
 21581  	if err := tp.ReadStructEnd(ctx); err != nil {
 21582  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21583  	}
 21584  	return nil
 21585  }
 21586  
 21587  func (p *LPopByteArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 21588  	if v, err := tp.ReadString(ctx); err != nil {
 21589  		return thrift.PrependError("error reading field 1: ", err)
 21590  	} else {
 21591  		p.Appid = v
 21592  	}
 21593  	return nil
 21594  }
 21595  
 21596  func (p *LPopByteArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 21597  	if v, err := tp.ReadString(ctx); err != nil {
 21598  		return thrift.PrependError("error reading field 2: ", err)
 21599  	} else {
 21600  		p.Key = v
 21601  	}
 21602  	return nil
 21603  }
 21604  
 21605  func (p *LPopByteArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 21606  	if err := tp.WriteStructBegin(ctx, "LPopByte_args"); err != nil {
 21607  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21608  	}
 21609  	if p != nil {
 21610  		if err := p.writeField1(ctx, tp); err != nil {
 21611  			return err
 21612  		}
 21613  		if err := p.writeField2(ctx, tp); err != nil {
 21614  			return err
 21615  		}
 21616  	}
 21617  	if err := tp.WriteFieldStop(ctx); err != nil {
 21618  		return thrift.PrependError("write field stop error: ", err)
 21619  	}
 21620  	if err := tp.WriteStructEnd(ctx); err != nil {
 21621  		return thrift.PrependError("write struct stop error: ", err)
 21622  	}
 21623  	return nil
 21624  }
 21625  
 21626  func (p *LPopByteArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 21627  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 21628  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 21629  	}
 21630  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 21631  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 21632  	}
 21633  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21634  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 21635  	}
 21636  	return err
 21637  }
 21638  
 21639  func (p *LPopByteArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 21640  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 21641  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 21642  	}
 21643  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 21644  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 21645  	}
 21646  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21647  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 21648  	}
 21649  	return err
 21650  }
 21651  
 21652  func (p *LPopByteArgs) String() string {
 21653  	if p == nil {
 21654  		return "<nil>"
 21655  	}
 21656  	return fmt.Sprintf("LPopByteArgs(%+v)", *p)
 21657  }
 21658  
 21659  // Attributes:
 21660  //  - Success
 21661  type LPopByteResult struct {
 21662  	Success *BytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 21663  }
 21664  
 21665  func NewLPopByteResult() *LPopByteResult {
 21666  	return &LPopByteResult{}
 21667  }
 21668  
 21669  var LPopByteResult_Success_DEFAULT *BytesResponse
 21670  
 21671  func (p *LPopByteResult) GetSuccess() *BytesResponse {
 21672  	if !p.IsSetSuccess() {
 21673  		return LPopByteResult_Success_DEFAULT
 21674  	}
 21675  	return p.Success
 21676  }
 21677  func (p *LPopByteResult) IsSetSuccess() bool {
 21678  	return p.Success != nil
 21679  }
 21680  
 21681  func (p *LPopByteResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 21682  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21683  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21684  	}
 21685  
 21686  	for {
 21687  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21688  		if err != nil {
 21689  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21690  		}
 21691  		if fieldTypeId == thrift.STOP {
 21692  			break
 21693  		}
 21694  		switch fieldId {
 21695  		case 0:
 21696  			if fieldTypeId == thrift.STRUCT {
 21697  				if err := p.ReadField0(ctx, tp); err != nil {
 21698  					return err
 21699  				}
 21700  			} else {
 21701  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21702  					return err
 21703  				}
 21704  			}
 21705  		default:
 21706  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21707  				return err
 21708  			}
 21709  		}
 21710  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21711  			return err
 21712  		}
 21713  	}
 21714  	if err := tp.ReadStructEnd(ctx); err != nil {
 21715  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21716  	}
 21717  	return nil
 21718  }
 21719  
 21720  func (p *LPopByteResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 21721  	p.Success = &BytesResponse{}
 21722  	if err := p.Success.Read(ctx, tp); err != nil {
 21723  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 21724  	}
 21725  	return nil
 21726  }
 21727  
 21728  func (p *LPopByteResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 21729  	if err := tp.WriteStructBegin(ctx, "LPopByte_result"); err != nil {
 21730  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21731  	}
 21732  	if p != nil {
 21733  		if err := p.writeField0(ctx, tp); err != nil {
 21734  			return err
 21735  		}
 21736  	}
 21737  	if err := tp.WriteFieldStop(ctx); err != nil {
 21738  		return thrift.PrependError("write field stop error: ", err)
 21739  	}
 21740  	if err := tp.WriteStructEnd(ctx); err != nil {
 21741  		return thrift.PrependError("write struct stop error: ", err)
 21742  	}
 21743  	return nil
 21744  }
 21745  
 21746  func (p *LPopByteResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 21747  	if p.IsSetSuccess() {
 21748  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 21749  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 21750  		}
 21751  		if err := p.Success.Write(ctx, tp); err != nil {
 21752  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 21753  		}
 21754  		if err := tp.WriteFieldEnd(ctx); err != nil {
 21755  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 21756  		}
 21757  	}
 21758  	return err
 21759  }
 21760  
 21761  func (p *LPopByteResult) String() string {
 21762  	if p == nil {
 21763  		return "<nil>"
 21764  	}
 21765  	return fmt.Sprintf("LPopByteResult(%+v)", *p)
 21766  }
 21767  
 21768  // Attributes:
 21769  //  - Appid
 21770  //  - Key
 21771  type RPopArgs struct {
 21772  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 21773  	Key   string `thrift:"key,2" db:"key" json:"key"`
 21774  }
 21775  
 21776  func NewRPopArgs() *RPopArgs {
 21777  	return &RPopArgs{}
 21778  }
 21779  
 21780  func (p *RPopArgs) GetAppid() string {
 21781  	return p.Appid
 21782  }
 21783  
 21784  func (p *RPopArgs) GetKey() string {
 21785  	return p.Key
 21786  }
 21787  func (p *RPopArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 21788  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21789  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21790  	}
 21791  
 21792  	for {
 21793  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21794  		if err != nil {
 21795  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21796  		}
 21797  		if fieldTypeId == thrift.STOP {
 21798  			break
 21799  		}
 21800  		switch fieldId {
 21801  		case 1:
 21802  			if fieldTypeId == thrift.STRING {
 21803  				if err := p.ReadField1(ctx, tp); err != nil {
 21804  					return err
 21805  				}
 21806  			} else {
 21807  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21808  					return err
 21809  				}
 21810  			}
 21811  		case 2:
 21812  			if fieldTypeId == thrift.STRING {
 21813  				if err := p.ReadField2(ctx, tp); err != nil {
 21814  					return err
 21815  				}
 21816  			} else {
 21817  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21818  					return err
 21819  				}
 21820  			}
 21821  		default:
 21822  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21823  				return err
 21824  			}
 21825  		}
 21826  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21827  			return err
 21828  		}
 21829  	}
 21830  	if err := tp.ReadStructEnd(ctx); err != nil {
 21831  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21832  	}
 21833  	return nil
 21834  }
 21835  
 21836  func (p *RPopArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 21837  	if v, err := tp.ReadString(ctx); err != nil {
 21838  		return thrift.PrependError("error reading field 1: ", err)
 21839  	} else {
 21840  		p.Appid = v
 21841  	}
 21842  	return nil
 21843  }
 21844  
 21845  func (p *RPopArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 21846  	if v, err := tp.ReadString(ctx); err != nil {
 21847  		return thrift.PrependError("error reading field 2: ", err)
 21848  	} else {
 21849  		p.Key = v
 21850  	}
 21851  	return nil
 21852  }
 21853  
 21854  func (p *RPopArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 21855  	if err := tp.WriteStructBegin(ctx, "RPop_args"); err != nil {
 21856  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21857  	}
 21858  	if p != nil {
 21859  		if err := p.writeField1(ctx, tp); err != nil {
 21860  			return err
 21861  		}
 21862  		if err := p.writeField2(ctx, tp); err != nil {
 21863  			return err
 21864  		}
 21865  	}
 21866  	if err := tp.WriteFieldStop(ctx); err != nil {
 21867  		return thrift.PrependError("write field stop error: ", err)
 21868  	}
 21869  	if err := tp.WriteStructEnd(ctx); err != nil {
 21870  		return thrift.PrependError("write struct stop error: ", err)
 21871  	}
 21872  	return nil
 21873  }
 21874  
 21875  func (p *RPopArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 21876  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 21877  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 21878  	}
 21879  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 21880  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 21881  	}
 21882  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21883  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 21884  	}
 21885  	return err
 21886  }
 21887  
 21888  func (p *RPopArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 21889  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 21890  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 21891  	}
 21892  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 21893  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 21894  	}
 21895  	if err := tp.WriteFieldEnd(ctx); err != nil {
 21896  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 21897  	}
 21898  	return err
 21899  }
 21900  
 21901  func (p *RPopArgs) String() string {
 21902  	if p == nil {
 21903  		return "<nil>"
 21904  	}
 21905  	return fmt.Sprintf("RPopArgs(%+v)", *p)
 21906  }
 21907  
 21908  // Attributes:
 21909  //  - Success
 21910  type RPopResult struct {
 21911  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 21912  }
 21913  
 21914  func NewRPopResult() *RPopResult {
 21915  	return &RPopResult{}
 21916  }
 21917  
 21918  var RPopResult_Success_DEFAULT *Response
 21919  
 21920  func (p *RPopResult) GetSuccess() *Response {
 21921  	if !p.IsSetSuccess() {
 21922  		return RPopResult_Success_DEFAULT
 21923  	}
 21924  	return p.Success
 21925  }
 21926  func (p *RPopResult) IsSetSuccess() bool {
 21927  	return p.Success != nil
 21928  }
 21929  
 21930  func (p *RPopResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 21931  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 21932  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 21933  	}
 21934  
 21935  	for {
 21936  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 21937  		if err != nil {
 21938  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 21939  		}
 21940  		if fieldTypeId == thrift.STOP {
 21941  			break
 21942  		}
 21943  		switch fieldId {
 21944  		case 0:
 21945  			if fieldTypeId == thrift.STRUCT {
 21946  				if err := p.ReadField0(ctx, tp); err != nil {
 21947  					return err
 21948  				}
 21949  			} else {
 21950  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21951  					return err
 21952  				}
 21953  			}
 21954  		default:
 21955  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 21956  				return err
 21957  			}
 21958  		}
 21959  		if err := tp.ReadFieldEnd(ctx); err != nil {
 21960  			return err
 21961  		}
 21962  	}
 21963  	if err := tp.ReadStructEnd(ctx); err != nil {
 21964  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 21965  	}
 21966  	return nil
 21967  }
 21968  
 21969  func (p *RPopResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 21970  	p.Success = &Response{}
 21971  	if err := p.Success.Read(ctx, tp); err != nil {
 21972  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 21973  	}
 21974  	return nil
 21975  }
 21976  
 21977  func (p *RPopResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 21978  	if err := tp.WriteStructBegin(ctx, "RPop_result"); err != nil {
 21979  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 21980  	}
 21981  	if p != nil {
 21982  		if err := p.writeField0(ctx, tp); err != nil {
 21983  			return err
 21984  		}
 21985  	}
 21986  	if err := tp.WriteFieldStop(ctx); err != nil {
 21987  		return thrift.PrependError("write field stop error: ", err)
 21988  	}
 21989  	if err := tp.WriteStructEnd(ctx); err != nil {
 21990  		return thrift.PrependError("write struct stop error: ", err)
 21991  	}
 21992  	return nil
 21993  }
 21994  
 21995  func (p *RPopResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 21996  	if p.IsSetSuccess() {
 21997  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 21998  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 21999  		}
 22000  		if err := p.Success.Write(ctx, tp); err != nil {
 22001  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 22002  		}
 22003  		if err := tp.WriteFieldEnd(ctx); err != nil {
 22004  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 22005  		}
 22006  	}
 22007  	return err
 22008  }
 22009  
 22010  func (p *RPopResult) String() string {
 22011  	if p == nil {
 22012  		return "<nil>"
 22013  	}
 22014  	return fmt.Sprintf("RPopResult(%+v)", *p)
 22015  }
 22016  
 22017  // Attributes:
 22018  //  - Appid
 22019  //  - Key
 22020  type RPopByteArgs struct {
 22021  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 22022  	Key   string `thrift:"key,2" db:"key" json:"key"`
 22023  }
 22024  
 22025  func NewRPopByteArgs() *RPopByteArgs {
 22026  	return &RPopByteArgs{}
 22027  }
 22028  
 22029  func (p *RPopByteArgs) GetAppid() string {
 22030  	return p.Appid
 22031  }
 22032  
 22033  func (p *RPopByteArgs) GetKey() string {
 22034  	return p.Key
 22035  }
 22036  func (p *RPopByteArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 22037  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22038  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22039  	}
 22040  
 22041  	for {
 22042  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22043  		if err != nil {
 22044  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22045  		}
 22046  		if fieldTypeId == thrift.STOP {
 22047  			break
 22048  		}
 22049  		switch fieldId {
 22050  		case 1:
 22051  			if fieldTypeId == thrift.STRING {
 22052  				if err := p.ReadField1(ctx, tp); err != nil {
 22053  					return err
 22054  				}
 22055  			} else {
 22056  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22057  					return err
 22058  				}
 22059  			}
 22060  		case 2:
 22061  			if fieldTypeId == thrift.STRING {
 22062  				if err := p.ReadField2(ctx, tp); err != nil {
 22063  					return err
 22064  				}
 22065  			} else {
 22066  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22067  					return err
 22068  				}
 22069  			}
 22070  		default:
 22071  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22072  				return err
 22073  			}
 22074  		}
 22075  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22076  			return err
 22077  		}
 22078  	}
 22079  	if err := tp.ReadStructEnd(ctx); err != nil {
 22080  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22081  	}
 22082  	return nil
 22083  }
 22084  
 22085  func (p *RPopByteArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 22086  	if v, err := tp.ReadString(ctx); err != nil {
 22087  		return thrift.PrependError("error reading field 1: ", err)
 22088  	} else {
 22089  		p.Appid = v
 22090  	}
 22091  	return nil
 22092  }
 22093  
 22094  func (p *RPopByteArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 22095  	if v, err := tp.ReadString(ctx); err != nil {
 22096  		return thrift.PrependError("error reading field 2: ", err)
 22097  	} else {
 22098  		p.Key = v
 22099  	}
 22100  	return nil
 22101  }
 22102  
 22103  func (p *RPopByteArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 22104  	if err := tp.WriteStructBegin(ctx, "RPopByte_args"); err != nil {
 22105  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22106  	}
 22107  	if p != nil {
 22108  		if err := p.writeField1(ctx, tp); err != nil {
 22109  			return err
 22110  		}
 22111  		if err := p.writeField2(ctx, tp); err != nil {
 22112  			return err
 22113  		}
 22114  	}
 22115  	if err := tp.WriteFieldStop(ctx); err != nil {
 22116  		return thrift.PrependError("write field stop error: ", err)
 22117  	}
 22118  	if err := tp.WriteStructEnd(ctx); err != nil {
 22119  		return thrift.PrependError("write struct stop error: ", err)
 22120  	}
 22121  	return nil
 22122  }
 22123  
 22124  func (p *RPopByteArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 22125  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 22126  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 22127  	}
 22128  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 22129  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 22130  	}
 22131  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22132  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 22133  	}
 22134  	return err
 22135  }
 22136  
 22137  func (p *RPopByteArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 22138  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 22139  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 22140  	}
 22141  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 22142  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 22143  	}
 22144  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22145  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 22146  	}
 22147  	return err
 22148  }
 22149  
 22150  func (p *RPopByteArgs) String() string {
 22151  	if p == nil {
 22152  		return "<nil>"
 22153  	}
 22154  	return fmt.Sprintf("RPopByteArgs(%+v)", *p)
 22155  }
 22156  
 22157  // Attributes:
 22158  //  - Success
 22159  type RPopByteResult struct {
 22160  	Success *BytesResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 22161  }
 22162  
 22163  func NewRPopByteResult() *RPopByteResult {
 22164  	return &RPopByteResult{}
 22165  }
 22166  
 22167  var RPopByteResult_Success_DEFAULT *BytesResponse
 22168  
 22169  func (p *RPopByteResult) GetSuccess() *BytesResponse {
 22170  	if !p.IsSetSuccess() {
 22171  		return RPopByteResult_Success_DEFAULT
 22172  	}
 22173  	return p.Success
 22174  }
 22175  func (p *RPopByteResult) IsSetSuccess() bool {
 22176  	return p.Success != nil
 22177  }
 22178  
 22179  func (p *RPopByteResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 22180  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22181  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22182  	}
 22183  
 22184  	for {
 22185  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22186  		if err != nil {
 22187  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22188  		}
 22189  		if fieldTypeId == thrift.STOP {
 22190  			break
 22191  		}
 22192  		switch fieldId {
 22193  		case 0:
 22194  			if fieldTypeId == thrift.STRUCT {
 22195  				if err := p.ReadField0(ctx, tp); err != nil {
 22196  					return err
 22197  				}
 22198  			} else {
 22199  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22200  					return err
 22201  				}
 22202  			}
 22203  		default:
 22204  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22205  				return err
 22206  			}
 22207  		}
 22208  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22209  			return err
 22210  		}
 22211  	}
 22212  	if err := tp.ReadStructEnd(ctx); err != nil {
 22213  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22214  	}
 22215  	return nil
 22216  }
 22217  
 22218  func (p *RPopByteResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 22219  	p.Success = &BytesResponse{}
 22220  	if err := p.Success.Read(ctx, tp); err != nil {
 22221  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 22222  	}
 22223  	return nil
 22224  }
 22225  
 22226  func (p *RPopByteResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 22227  	if err := tp.WriteStructBegin(ctx, "RPopByte_result"); err != nil {
 22228  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22229  	}
 22230  	if p != nil {
 22231  		if err := p.writeField0(ctx, tp); err != nil {
 22232  			return err
 22233  		}
 22234  	}
 22235  	if err := tp.WriteFieldStop(ctx); err != nil {
 22236  		return thrift.PrependError("write field stop error: ", err)
 22237  	}
 22238  	if err := tp.WriteStructEnd(ctx); err != nil {
 22239  		return thrift.PrependError("write struct stop error: ", err)
 22240  	}
 22241  	return nil
 22242  }
 22243  
 22244  func (p *RPopByteResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 22245  	if p.IsSetSuccess() {
 22246  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 22247  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 22248  		}
 22249  		if err := p.Success.Write(ctx, tp); err != nil {
 22250  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 22251  		}
 22252  		if err := tp.WriteFieldEnd(ctx); err != nil {
 22253  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 22254  		}
 22255  	}
 22256  	return err
 22257  }
 22258  
 22259  func (p *RPopByteResult) String() string {
 22260  	if p == nil {
 22261  		return "<nil>"
 22262  	}
 22263  	return fmt.Sprintf("RPopByteResult(%+v)", *p)
 22264  }
 22265  
 22266  // Attributes:
 22267  //  - Appid
 22268  //  - Key
 22269  //  - Pivot
 22270  //  - Value
 22271  type LInsertBeforeArgs struct {
 22272  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 22273  	Key   string `thrift:"key,2" db:"key" json:"key"`
 22274  	Pivot string `thrift:"pivot,3" db:"pivot" json:"pivot"`
 22275  	Value string `thrift:"value,4" db:"value" json:"value"`
 22276  }
 22277  
 22278  func NewLInsertBeforeArgs() *LInsertBeforeArgs {
 22279  	return &LInsertBeforeArgs{}
 22280  }
 22281  
 22282  func (p *LInsertBeforeArgs) GetAppid() string {
 22283  	return p.Appid
 22284  }
 22285  
 22286  func (p *LInsertBeforeArgs) GetKey() string {
 22287  	return p.Key
 22288  }
 22289  
 22290  func (p *LInsertBeforeArgs) GetPivot() string {
 22291  	return p.Pivot
 22292  }
 22293  
 22294  func (p *LInsertBeforeArgs) GetValue() string {
 22295  	return p.Value
 22296  }
 22297  func (p *LInsertBeforeArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 22298  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22299  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22300  	}
 22301  
 22302  	for {
 22303  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22304  		if err != nil {
 22305  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22306  		}
 22307  		if fieldTypeId == thrift.STOP {
 22308  			break
 22309  		}
 22310  		switch fieldId {
 22311  		case 1:
 22312  			if fieldTypeId == thrift.STRING {
 22313  				if err := p.ReadField1(ctx, tp); err != nil {
 22314  					return err
 22315  				}
 22316  			} else {
 22317  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22318  					return err
 22319  				}
 22320  			}
 22321  		case 2:
 22322  			if fieldTypeId == thrift.STRING {
 22323  				if err := p.ReadField2(ctx, tp); err != nil {
 22324  					return err
 22325  				}
 22326  			} else {
 22327  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22328  					return err
 22329  				}
 22330  			}
 22331  		case 3:
 22332  			if fieldTypeId == thrift.STRING {
 22333  				if err := p.ReadField3(ctx, tp); err != nil {
 22334  					return err
 22335  				}
 22336  			} else {
 22337  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22338  					return err
 22339  				}
 22340  			}
 22341  		case 4:
 22342  			if fieldTypeId == thrift.STRING {
 22343  				if err := p.ReadField4(ctx, tp); err != nil {
 22344  					return err
 22345  				}
 22346  			} else {
 22347  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22348  					return err
 22349  				}
 22350  			}
 22351  		default:
 22352  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22353  				return err
 22354  			}
 22355  		}
 22356  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22357  			return err
 22358  		}
 22359  	}
 22360  	if err := tp.ReadStructEnd(ctx); err != nil {
 22361  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22362  	}
 22363  	return nil
 22364  }
 22365  
 22366  func (p *LInsertBeforeArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 22367  	if v, err := tp.ReadString(ctx); err != nil {
 22368  		return thrift.PrependError("error reading field 1: ", err)
 22369  	} else {
 22370  		p.Appid = v
 22371  	}
 22372  	return nil
 22373  }
 22374  
 22375  func (p *LInsertBeforeArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 22376  	if v, err := tp.ReadString(ctx); err != nil {
 22377  		return thrift.PrependError("error reading field 2: ", err)
 22378  	} else {
 22379  		p.Key = v
 22380  	}
 22381  	return nil
 22382  }
 22383  
 22384  func (p *LInsertBeforeArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 22385  	if v, err := tp.ReadString(ctx); err != nil {
 22386  		return thrift.PrependError("error reading field 3: ", err)
 22387  	} else {
 22388  		p.Pivot = v
 22389  	}
 22390  	return nil
 22391  }
 22392  
 22393  func (p *LInsertBeforeArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 22394  	if v, err := tp.ReadString(ctx); err != nil {
 22395  		return thrift.PrependError("error reading field 4: ", err)
 22396  	} else {
 22397  		p.Value = v
 22398  	}
 22399  	return nil
 22400  }
 22401  
 22402  func (p *LInsertBeforeArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 22403  	if err := tp.WriteStructBegin(ctx, "LInsertBefore_args"); err != nil {
 22404  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22405  	}
 22406  	if p != nil {
 22407  		if err := p.writeField1(ctx, tp); err != nil {
 22408  			return err
 22409  		}
 22410  		if err := p.writeField2(ctx, tp); err != nil {
 22411  			return err
 22412  		}
 22413  		if err := p.writeField3(ctx, tp); err != nil {
 22414  			return err
 22415  		}
 22416  		if err := p.writeField4(ctx, tp); err != nil {
 22417  			return err
 22418  		}
 22419  	}
 22420  	if err := tp.WriteFieldStop(ctx); err != nil {
 22421  		return thrift.PrependError("write field stop error: ", err)
 22422  	}
 22423  	if err := tp.WriteStructEnd(ctx); err != nil {
 22424  		return thrift.PrependError("write struct stop error: ", err)
 22425  	}
 22426  	return nil
 22427  }
 22428  
 22429  func (p *LInsertBeforeArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 22430  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 22431  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 22432  	}
 22433  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 22434  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 22435  	}
 22436  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22437  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 22438  	}
 22439  	return err
 22440  }
 22441  
 22442  func (p *LInsertBeforeArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 22443  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 22444  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 22445  	}
 22446  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 22447  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 22448  	}
 22449  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22450  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 22451  	}
 22452  	return err
 22453  }
 22454  
 22455  func (p *LInsertBeforeArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 22456  	if err := tp.WriteFieldBegin(ctx, "pivot", thrift.STRING, 3); err != nil {
 22457  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:pivot: ", p), err)
 22458  	}
 22459  	if err := tp.WriteString(ctx, string(p.Pivot)); err != nil {
 22460  		return thrift.PrependError(fmt.Sprintf("%T.pivot (3) field write error: ", p), err)
 22461  	}
 22462  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22463  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:pivot: ", p), err)
 22464  	}
 22465  	return err
 22466  }
 22467  
 22468  func (p *LInsertBeforeArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 22469  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
 22470  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
 22471  	}
 22472  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
 22473  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
 22474  	}
 22475  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22476  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
 22477  	}
 22478  	return err
 22479  }
 22480  
 22481  func (p *LInsertBeforeArgs) String() string {
 22482  	if p == nil {
 22483  		return "<nil>"
 22484  	}
 22485  	return fmt.Sprintf("LInsertBeforeArgs(%+v)", *p)
 22486  }
 22487  
 22488  // Attributes:
 22489  //  - Success
 22490  type LInsertBeforeResult struct {
 22491  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 22492  }
 22493  
 22494  func NewLInsertBeforeResult() *LInsertBeforeResult {
 22495  	return &LInsertBeforeResult{}
 22496  }
 22497  
 22498  var LInsertBeforeResult_Success_DEFAULT *IntResponse
 22499  
 22500  func (p *LInsertBeforeResult) GetSuccess() *IntResponse {
 22501  	if !p.IsSetSuccess() {
 22502  		return LInsertBeforeResult_Success_DEFAULT
 22503  	}
 22504  	return p.Success
 22505  }
 22506  func (p *LInsertBeforeResult) IsSetSuccess() bool {
 22507  	return p.Success != nil
 22508  }
 22509  
 22510  func (p *LInsertBeforeResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 22511  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22512  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22513  	}
 22514  
 22515  	for {
 22516  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22517  		if err != nil {
 22518  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22519  		}
 22520  		if fieldTypeId == thrift.STOP {
 22521  			break
 22522  		}
 22523  		switch fieldId {
 22524  		case 0:
 22525  			if fieldTypeId == thrift.STRUCT {
 22526  				if err := p.ReadField0(ctx, tp); err != nil {
 22527  					return err
 22528  				}
 22529  			} else {
 22530  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22531  					return err
 22532  				}
 22533  			}
 22534  		default:
 22535  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22536  				return err
 22537  			}
 22538  		}
 22539  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22540  			return err
 22541  		}
 22542  	}
 22543  	if err := tp.ReadStructEnd(ctx); err != nil {
 22544  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22545  	}
 22546  	return nil
 22547  }
 22548  
 22549  func (p *LInsertBeforeResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 22550  	p.Success = &IntResponse{}
 22551  	if err := p.Success.Read(ctx, tp); err != nil {
 22552  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 22553  	}
 22554  	return nil
 22555  }
 22556  
 22557  func (p *LInsertBeforeResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 22558  	if err := tp.WriteStructBegin(ctx, "LInsertBefore_result"); err != nil {
 22559  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22560  	}
 22561  	if p != nil {
 22562  		if err := p.writeField0(ctx, tp); err != nil {
 22563  			return err
 22564  		}
 22565  	}
 22566  	if err := tp.WriteFieldStop(ctx); err != nil {
 22567  		return thrift.PrependError("write field stop error: ", err)
 22568  	}
 22569  	if err := tp.WriteStructEnd(ctx); err != nil {
 22570  		return thrift.PrependError("write struct stop error: ", err)
 22571  	}
 22572  	return nil
 22573  }
 22574  
 22575  func (p *LInsertBeforeResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 22576  	if p.IsSetSuccess() {
 22577  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 22578  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 22579  		}
 22580  		if err := p.Success.Write(ctx, tp); err != nil {
 22581  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 22582  		}
 22583  		if err := tp.WriteFieldEnd(ctx); err != nil {
 22584  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 22585  		}
 22586  	}
 22587  	return err
 22588  }
 22589  
 22590  func (p *LInsertBeforeResult) String() string {
 22591  	if p == nil {
 22592  		return "<nil>"
 22593  	}
 22594  	return fmt.Sprintf("LInsertBeforeResult(%+v)", *p)
 22595  }
 22596  
 22597  // Attributes:
 22598  //  - Appid
 22599  //  - Key
 22600  //  - Pivot
 22601  //  - Value
 22602  type LInsertAfterArgs struct {
 22603  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 22604  	Key   string `thrift:"key,2" db:"key" json:"key"`
 22605  	Pivot string `thrift:"pivot,3" db:"pivot" json:"pivot"`
 22606  	Value string `thrift:"value,4" db:"value" json:"value"`
 22607  }
 22608  
 22609  func NewLInsertAfterArgs() *LInsertAfterArgs {
 22610  	return &LInsertAfterArgs{}
 22611  }
 22612  
 22613  func (p *LInsertAfterArgs) GetAppid() string {
 22614  	return p.Appid
 22615  }
 22616  
 22617  func (p *LInsertAfterArgs) GetKey() string {
 22618  	return p.Key
 22619  }
 22620  
 22621  func (p *LInsertAfterArgs) GetPivot() string {
 22622  	return p.Pivot
 22623  }
 22624  
 22625  func (p *LInsertAfterArgs) GetValue() string {
 22626  	return p.Value
 22627  }
 22628  func (p *LInsertAfterArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 22629  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22630  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22631  	}
 22632  
 22633  	for {
 22634  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22635  		if err != nil {
 22636  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22637  		}
 22638  		if fieldTypeId == thrift.STOP {
 22639  			break
 22640  		}
 22641  		switch fieldId {
 22642  		case 1:
 22643  			if fieldTypeId == thrift.STRING {
 22644  				if err := p.ReadField1(ctx, tp); err != nil {
 22645  					return err
 22646  				}
 22647  			} else {
 22648  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22649  					return err
 22650  				}
 22651  			}
 22652  		case 2:
 22653  			if fieldTypeId == thrift.STRING {
 22654  				if err := p.ReadField2(ctx, tp); err != nil {
 22655  					return err
 22656  				}
 22657  			} else {
 22658  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22659  					return err
 22660  				}
 22661  			}
 22662  		case 3:
 22663  			if fieldTypeId == thrift.STRING {
 22664  				if err := p.ReadField3(ctx, tp); err != nil {
 22665  					return err
 22666  				}
 22667  			} else {
 22668  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22669  					return err
 22670  				}
 22671  			}
 22672  		case 4:
 22673  			if fieldTypeId == thrift.STRING {
 22674  				if err := p.ReadField4(ctx, tp); err != nil {
 22675  					return err
 22676  				}
 22677  			} else {
 22678  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22679  					return err
 22680  				}
 22681  			}
 22682  		default:
 22683  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22684  				return err
 22685  			}
 22686  		}
 22687  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22688  			return err
 22689  		}
 22690  	}
 22691  	if err := tp.ReadStructEnd(ctx); err != nil {
 22692  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22693  	}
 22694  	return nil
 22695  }
 22696  
 22697  func (p *LInsertAfterArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 22698  	if v, err := tp.ReadString(ctx); err != nil {
 22699  		return thrift.PrependError("error reading field 1: ", err)
 22700  	} else {
 22701  		p.Appid = v
 22702  	}
 22703  	return nil
 22704  }
 22705  
 22706  func (p *LInsertAfterArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 22707  	if v, err := tp.ReadString(ctx); err != nil {
 22708  		return thrift.PrependError("error reading field 2: ", err)
 22709  	} else {
 22710  		p.Key = v
 22711  	}
 22712  	return nil
 22713  }
 22714  
 22715  func (p *LInsertAfterArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 22716  	if v, err := tp.ReadString(ctx); err != nil {
 22717  		return thrift.PrependError("error reading field 3: ", err)
 22718  	} else {
 22719  		p.Pivot = v
 22720  	}
 22721  	return nil
 22722  }
 22723  
 22724  func (p *LInsertAfterArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 22725  	if v, err := tp.ReadString(ctx); err != nil {
 22726  		return thrift.PrependError("error reading field 4: ", err)
 22727  	} else {
 22728  		p.Value = v
 22729  	}
 22730  	return nil
 22731  }
 22732  
 22733  func (p *LInsertAfterArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 22734  	if err := tp.WriteStructBegin(ctx, "LInsertAfter_args"); err != nil {
 22735  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22736  	}
 22737  	if p != nil {
 22738  		if err := p.writeField1(ctx, tp); err != nil {
 22739  			return err
 22740  		}
 22741  		if err := p.writeField2(ctx, tp); err != nil {
 22742  			return err
 22743  		}
 22744  		if err := p.writeField3(ctx, tp); err != nil {
 22745  			return err
 22746  		}
 22747  		if err := p.writeField4(ctx, tp); err != nil {
 22748  			return err
 22749  		}
 22750  	}
 22751  	if err := tp.WriteFieldStop(ctx); err != nil {
 22752  		return thrift.PrependError("write field stop error: ", err)
 22753  	}
 22754  	if err := tp.WriteStructEnd(ctx); err != nil {
 22755  		return thrift.PrependError("write struct stop error: ", err)
 22756  	}
 22757  	return nil
 22758  }
 22759  
 22760  func (p *LInsertAfterArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 22761  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 22762  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 22763  	}
 22764  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 22765  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 22766  	}
 22767  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22768  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 22769  	}
 22770  	return err
 22771  }
 22772  
 22773  func (p *LInsertAfterArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 22774  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 22775  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 22776  	}
 22777  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 22778  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 22779  	}
 22780  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22781  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 22782  	}
 22783  	return err
 22784  }
 22785  
 22786  func (p *LInsertAfterArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 22787  	if err := tp.WriteFieldBegin(ctx, "pivot", thrift.STRING, 3); err != nil {
 22788  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:pivot: ", p), err)
 22789  	}
 22790  	if err := tp.WriteString(ctx, string(p.Pivot)); err != nil {
 22791  		return thrift.PrependError(fmt.Sprintf("%T.pivot (3) field write error: ", p), err)
 22792  	}
 22793  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22794  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:pivot: ", p), err)
 22795  	}
 22796  	return err
 22797  }
 22798  
 22799  func (p *LInsertAfterArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 22800  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
 22801  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
 22802  	}
 22803  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
 22804  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
 22805  	}
 22806  	if err := tp.WriteFieldEnd(ctx); err != nil {
 22807  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
 22808  	}
 22809  	return err
 22810  }
 22811  
 22812  func (p *LInsertAfterArgs) String() string {
 22813  	if p == nil {
 22814  		return "<nil>"
 22815  	}
 22816  	return fmt.Sprintf("LInsertAfterArgs(%+v)", *p)
 22817  }
 22818  
 22819  // Attributes:
 22820  //  - Success
 22821  type LInsertAfterResult struct {
 22822  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 22823  }
 22824  
 22825  func NewLInsertAfterResult() *LInsertAfterResult {
 22826  	return &LInsertAfterResult{}
 22827  }
 22828  
 22829  var LInsertAfterResult_Success_DEFAULT *IntResponse
 22830  
 22831  func (p *LInsertAfterResult) GetSuccess() *IntResponse {
 22832  	if !p.IsSetSuccess() {
 22833  		return LInsertAfterResult_Success_DEFAULT
 22834  	}
 22835  	return p.Success
 22836  }
 22837  func (p *LInsertAfterResult) IsSetSuccess() bool {
 22838  	return p.Success != nil
 22839  }
 22840  
 22841  func (p *LInsertAfterResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 22842  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22843  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22844  	}
 22845  
 22846  	for {
 22847  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22848  		if err != nil {
 22849  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22850  		}
 22851  		if fieldTypeId == thrift.STOP {
 22852  			break
 22853  		}
 22854  		switch fieldId {
 22855  		case 0:
 22856  			if fieldTypeId == thrift.STRUCT {
 22857  				if err := p.ReadField0(ctx, tp); err != nil {
 22858  					return err
 22859  				}
 22860  			} else {
 22861  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22862  					return err
 22863  				}
 22864  			}
 22865  		default:
 22866  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22867  				return err
 22868  			}
 22869  		}
 22870  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22871  			return err
 22872  		}
 22873  	}
 22874  	if err := tp.ReadStructEnd(ctx); err != nil {
 22875  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22876  	}
 22877  	return nil
 22878  }
 22879  
 22880  func (p *LInsertAfterResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 22881  	p.Success = &IntResponse{}
 22882  	if err := p.Success.Read(ctx, tp); err != nil {
 22883  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 22884  	}
 22885  	return nil
 22886  }
 22887  
 22888  func (p *LInsertAfterResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 22889  	if err := tp.WriteStructBegin(ctx, "LInsertAfter_result"); err != nil {
 22890  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 22891  	}
 22892  	if p != nil {
 22893  		if err := p.writeField0(ctx, tp); err != nil {
 22894  			return err
 22895  		}
 22896  	}
 22897  	if err := tp.WriteFieldStop(ctx); err != nil {
 22898  		return thrift.PrependError("write field stop error: ", err)
 22899  	}
 22900  	if err := tp.WriteStructEnd(ctx); err != nil {
 22901  		return thrift.PrependError("write struct stop error: ", err)
 22902  	}
 22903  	return nil
 22904  }
 22905  
 22906  func (p *LInsertAfterResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 22907  	if p.IsSetSuccess() {
 22908  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 22909  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 22910  		}
 22911  		if err := p.Success.Write(ctx, tp); err != nil {
 22912  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 22913  		}
 22914  		if err := tp.WriteFieldEnd(ctx); err != nil {
 22915  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 22916  		}
 22917  	}
 22918  	return err
 22919  }
 22920  
 22921  func (p *LInsertAfterResult) String() string {
 22922  	if p == nil {
 22923  		return "<nil>"
 22924  	}
 22925  	return fmt.Sprintf("LInsertAfterResult(%+v)", *p)
 22926  }
 22927  
 22928  // Attributes:
 22929  //  - Appid
 22930  //  - Key
 22931  type LLenArgs struct {
 22932  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 22933  	Key   string `thrift:"key,2" db:"key" json:"key"`
 22934  }
 22935  
 22936  func NewLLenArgs() *LLenArgs {
 22937  	return &LLenArgs{}
 22938  }
 22939  
 22940  func (p *LLenArgs) GetAppid() string {
 22941  	return p.Appid
 22942  }
 22943  
 22944  func (p *LLenArgs) GetKey() string {
 22945  	return p.Key
 22946  }
 22947  func (p *LLenArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 22948  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 22949  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 22950  	}
 22951  
 22952  	for {
 22953  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 22954  		if err != nil {
 22955  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 22956  		}
 22957  		if fieldTypeId == thrift.STOP {
 22958  			break
 22959  		}
 22960  		switch fieldId {
 22961  		case 1:
 22962  			if fieldTypeId == thrift.STRING {
 22963  				if err := p.ReadField1(ctx, tp); err != nil {
 22964  					return err
 22965  				}
 22966  			} else {
 22967  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22968  					return err
 22969  				}
 22970  			}
 22971  		case 2:
 22972  			if fieldTypeId == thrift.STRING {
 22973  				if err := p.ReadField2(ctx, tp); err != nil {
 22974  					return err
 22975  				}
 22976  			} else {
 22977  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22978  					return err
 22979  				}
 22980  			}
 22981  		default:
 22982  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 22983  				return err
 22984  			}
 22985  		}
 22986  		if err := tp.ReadFieldEnd(ctx); err != nil {
 22987  			return err
 22988  		}
 22989  	}
 22990  	if err := tp.ReadStructEnd(ctx); err != nil {
 22991  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 22992  	}
 22993  	return nil
 22994  }
 22995  
 22996  func (p *LLenArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 22997  	if v, err := tp.ReadString(ctx); err != nil {
 22998  		return thrift.PrependError("error reading field 1: ", err)
 22999  	} else {
 23000  		p.Appid = v
 23001  	}
 23002  	return nil
 23003  }
 23004  
 23005  func (p *LLenArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 23006  	if v, err := tp.ReadString(ctx); err != nil {
 23007  		return thrift.PrependError("error reading field 2: ", err)
 23008  	} else {
 23009  		p.Key = v
 23010  	}
 23011  	return nil
 23012  }
 23013  
 23014  func (p *LLenArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 23015  	if err := tp.WriteStructBegin(ctx, "LLen_args"); err != nil {
 23016  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23017  	}
 23018  	if p != nil {
 23019  		if err := p.writeField1(ctx, tp); err != nil {
 23020  			return err
 23021  		}
 23022  		if err := p.writeField2(ctx, tp); err != nil {
 23023  			return err
 23024  		}
 23025  	}
 23026  	if err := tp.WriteFieldStop(ctx); err != nil {
 23027  		return thrift.PrependError("write field stop error: ", err)
 23028  	}
 23029  	if err := tp.WriteStructEnd(ctx); err != nil {
 23030  		return thrift.PrependError("write struct stop error: ", err)
 23031  	}
 23032  	return nil
 23033  }
 23034  
 23035  func (p *LLenArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 23036  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 23037  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 23038  	}
 23039  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 23040  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 23041  	}
 23042  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23043  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 23044  	}
 23045  	return err
 23046  }
 23047  
 23048  func (p *LLenArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 23049  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 23050  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 23051  	}
 23052  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 23053  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 23054  	}
 23055  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23056  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 23057  	}
 23058  	return err
 23059  }
 23060  
 23061  func (p *LLenArgs) String() string {
 23062  	if p == nil {
 23063  		return "<nil>"
 23064  	}
 23065  	return fmt.Sprintf("LLenArgs(%+v)", *p)
 23066  }
 23067  
 23068  // Attributes:
 23069  //  - Success
 23070  type LLenResult struct {
 23071  	Success *IntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 23072  }
 23073  
 23074  func NewLLenResult() *LLenResult {
 23075  	return &LLenResult{}
 23076  }
 23077  
 23078  var LLenResult_Success_DEFAULT *IntResponse
 23079  
 23080  func (p *LLenResult) GetSuccess() *IntResponse {
 23081  	if !p.IsSetSuccess() {
 23082  		return LLenResult_Success_DEFAULT
 23083  	}
 23084  	return p.Success
 23085  }
 23086  func (p *LLenResult) IsSetSuccess() bool {
 23087  	return p.Success != nil
 23088  }
 23089  
 23090  func (p *LLenResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 23091  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23092  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23093  	}
 23094  
 23095  	for {
 23096  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23097  		if err != nil {
 23098  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23099  		}
 23100  		if fieldTypeId == thrift.STOP {
 23101  			break
 23102  		}
 23103  		switch fieldId {
 23104  		case 0:
 23105  			if fieldTypeId == thrift.STRUCT {
 23106  				if err := p.ReadField0(ctx, tp); err != nil {
 23107  					return err
 23108  				}
 23109  			} else {
 23110  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23111  					return err
 23112  				}
 23113  			}
 23114  		default:
 23115  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23116  				return err
 23117  			}
 23118  		}
 23119  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23120  			return err
 23121  		}
 23122  	}
 23123  	if err := tp.ReadStructEnd(ctx); err != nil {
 23124  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23125  	}
 23126  	return nil
 23127  }
 23128  
 23129  func (p *LLenResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 23130  	p.Success = &IntResponse{}
 23131  	if err := p.Success.Read(ctx, tp); err != nil {
 23132  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 23133  	}
 23134  	return nil
 23135  }
 23136  
 23137  func (p *LLenResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 23138  	if err := tp.WriteStructBegin(ctx, "LLen_result"); err != nil {
 23139  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23140  	}
 23141  	if p != nil {
 23142  		if err := p.writeField0(ctx, tp); err != nil {
 23143  			return err
 23144  		}
 23145  	}
 23146  	if err := tp.WriteFieldStop(ctx); err != nil {
 23147  		return thrift.PrependError("write field stop error: ", err)
 23148  	}
 23149  	if err := tp.WriteStructEnd(ctx); err != nil {
 23150  		return thrift.PrependError("write struct stop error: ", err)
 23151  	}
 23152  	return nil
 23153  }
 23154  
 23155  func (p *LLenResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 23156  	if p.IsSetSuccess() {
 23157  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 23158  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 23159  		}
 23160  		if err := p.Success.Write(ctx, tp); err != nil {
 23161  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 23162  		}
 23163  		if err := tp.WriteFieldEnd(ctx); err != nil {
 23164  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 23165  		}
 23166  	}
 23167  	return err
 23168  }
 23169  
 23170  func (p *LLenResult) String() string {
 23171  	if p == nil {
 23172  		return "<nil>"
 23173  	}
 23174  	return fmt.Sprintf("LLenResult(%+v)", *p)
 23175  }
 23176  
 23177  // Attributes:
 23178  //  - Appid
 23179  //  - Keys
 23180  type MlLenArgs struct {
 23181  	Appid string   `thrift:"appid,1" db:"appid" json:"appid"`
 23182  	Keys  []string `thrift:"keys,2" db:"keys" json:"keys"`
 23183  }
 23184  
 23185  func NewMLLenArgs() *MlLenArgs {
 23186  	return &MlLenArgs{}
 23187  }
 23188  
 23189  func (p *MlLenArgs) GetAppid() string {
 23190  	return p.Appid
 23191  }
 23192  
 23193  func (p *MlLenArgs) GetKeys() []string {
 23194  	return p.Keys
 23195  }
 23196  func (p *MlLenArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 23197  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23198  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23199  	}
 23200  
 23201  	for {
 23202  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23203  		if err != nil {
 23204  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23205  		}
 23206  		if fieldTypeId == thrift.STOP {
 23207  			break
 23208  		}
 23209  		switch fieldId {
 23210  		case 1:
 23211  			if fieldTypeId == thrift.STRING {
 23212  				if err := p.ReadField1(ctx, tp); err != nil {
 23213  					return err
 23214  				}
 23215  			} else {
 23216  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23217  					return err
 23218  				}
 23219  			}
 23220  		case 2:
 23221  			if fieldTypeId == thrift.LIST {
 23222  				if err := p.ReadField2(ctx, tp); err != nil {
 23223  					return err
 23224  				}
 23225  			} else {
 23226  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23227  					return err
 23228  				}
 23229  			}
 23230  		default:
 23231  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23232  				return err
 23233  			}
 23234  		}
 23235  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23236  			return err
 23237  		}
 23238  	}
 23239  	if err := tp.ReadStructEnd(ctx); err != nil {
 23240  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23241  	}
 23242  	return nil
 23243  }
 23244  
 23245  func (p *MlLenArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 23246  	if v, err := tp.ReadString(ctx); err != nil {
 23247  		return thrift.PrependError("error reading field 1: ", err)
 23248  	} else {
 23249  		p.Appid = v
 23250  	}
 23251  	return nil
 23252  }
 23253  
 23254  func (p *MlLenArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 23255  	_, size, err := tp.ReadListBegin(ctx)
 23256  	if err != nil {
 23257  		return thrift.PrependError("error reading list begin: ", err)
 23258  	}
 23259  	tSlice := make([]string, 0, size)
 23260  	p.Keys = tSlice
 23261  	for i := 0; i < size; i++ {
 23262  		var _elem202 string
 23263  		if v, err := tp.ReadString(ctx); err != nil {
 23264  			return thrift.PrependError("error reading field 0: ", err)
 23265  		} else {
 23266  			_elem202 = v
 23267  		}
 23268  		p.Keys = append(p.Keys, _elem202)
 23269  	}
 23270  	if err := tp.ReadListEnd(ctx); err != nil {
 23271  		return thrift.PrependError("error reading list end: ", err)
 23272  	}
 23273  	return nil
 23274  }
 23275  
 23276  func (p *MlLenArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 23277  	if err := tp.WriteStructBegin(ctx, "MLLen_args"); err != nil {
 23278  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23279  	}
 23280  	if p != nil {
 23281  		if err := p.writeField1(ctx, tp); err != nil {
 23282  			return err
 23283  		}
 23284  		if err := p.writeField2(ctx, tp); err != nil {
 23285  			return err
 23286  		}
 23287  	}
 23288  	if err := tp.WriteFieldStop(ctx); err != nil {
 23289  		return thrift.PrependError("write field stop error: ", err)
 23290  	}
 23291  	if err := tp.WriteStructEnd(ctx); err != nil {
 23292  		return thrift.PrependError("write struct stop error: ", err)
 23293  	}
 23294  	return nil
 23295  }
 23296  
 23297  func (p *MlLenArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 23298  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 23299  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 23300  	}
 23301  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 23302  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 23303  	}
 23304  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23305  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 23306  	}
 23307  	return err
 23308  }
 23309  
 23310  func (p *MlLenArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 23311  	if err := tp.WriteFieldBegin(ctx, "keys", thrift.LIST, 2); err != nil {
 23312  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:keys: ", p), err)
 23313  	}
 23314  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Keys)); err != nil {
 23315  		return thrift.PrependError("error writing list begin: ", err)
 23316  	}
 23317  	for _, v := range p.Keys {
 23318  		if err := tp.WriteString(ctx, string(v)); err != nil {
 23319  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 23320  		}
 23321  	}
 23322  	if err := tp.WriteListEnd(ctx); err != nil {
 23323  		return thrift.PrependError("error writing list end: ", err)
 23324  	}
 23325  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23326  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:keys: ", p), err)
 23327  	}
 23328  	return err
 23329  }
 23330  
 23331  func (p *MlLenArgs) String() string {
 23332  	if p == nil {
 23333  		return "<nil>"
 23334  	}
 23335  	return fmt.Sprintf("MlLenArgs(%+v)", *p)
 23336  }
 23337  
 23338  // Attributes:
 23339  //  - Success
 23340  type MlLenResult struct {
 23341  	Success *MIntResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 23342  }
 23343  
 23344  func NewMLLenResult() *MlLenResult {
 23345  	return &MlLenResult{}
 23346  }
 23347  
 23348  var MLLenResult_Success_DEFAULT *MIntResponse
 23349  
 23350  func (p *MlLenResult) GetSuccess() *MIntResponse {
 23351  	if !p.IsSetSuccess() {
 23352  		return MLLenResult_Success_DEFAULT
 23353  	}
 23354  	return p.Success
 23355  }
 23356  func (p *MlLenResult) IsSetSuccess() bool {
 23357  	return p.Success != nil
 23358  }
 23359  
 23360  func (p *MlLenResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 23361  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23362  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23363  	}
 23364  
 23365  	for {
 23366  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23367  		if err != nil {
 23368  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23369  		}
 23370  		if fieldTypeId == thrift.STOP {
 23371  			break
 23372  		}
 23373  		switch fieldId {
 23374  		case 0:
 23375  			if fieldTypeId == thrift.STRUCT {
 23376  				if err := p.ReadField0(ctx, tp); err != nil {
 23377  					return err
 23378  				}
 23379  			} else {
 23380  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23381  					return err
 23382  				}
 23383  			}
 23384  		default:
 23385  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23386  				return err
 23387  			}
 23388  		}
 23389  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23390  			return err
 23391  		}
 23392  	}
 23393  	if err := tp.ReadStructEnd(ctx); err != nil {
 23394  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23395  	}
 23396  	return nil
 23397  }
 23398  
 23399  func (p *MlLenResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 23400  	p.Success = &MIntResponse{}
 23401  	if err := p.Success.Read(ctx, tp); err != nil {
 23402  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 23403  	}
 23404  	return nil
 23405  }
 23406  
 23407  func (p *MlLenResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 23408  	if err := tp.WriteStructBegin(ctx, "MLLen_result"); err != nil {
 23409  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23410  	}
 23411  	if p != nil {
 23412  		if err := p.writeField0(ctx, tp); err != nil {
 23413  			return err
 23414  		}
 23415  	}
 23416  	if err := tp.WriteFieldStop(ctx); err != nil {
 23417  		return thrift.PrependError("write field stop error: ", err)
 23418  	}
 23419  	if err := tp.WriteStructEnd(ctx); err != nil {
 23420  		return thrift.PrependError("write struct stop error: ", err)
 23421  	}
 23422  	return nil
 23423  }
 23424  
 23425  func (p *MlLenResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 23426  	if p.IsSetSuccess() {
 23427  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 23428  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 23429  		}
 23430  		if err := p.Success.Write(ctx, tp); err != nil {
 23431  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 23432  		}
 23433  		if err := tp.WriteFieldEnd(ctx); err != nil {
 23434  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 23435  		}
 23436  	}
 23437  	return err
 23438  }
 23439  
 23440  func (p *MlLenResult) String() string {
 23441  	if p == nil {
 23442  		return "<nil>"
 23443  	}
 23444  	return fmt.Sprintf("MlLenResult(%+v)", *p)
 23445  }
 23446  
 23447  // Attributes:
 23448  //  - Appid
 23449  //  - Key
 23450  //  - Index
 23451  //  - Value
 23452  type LSetArgs struct {
 23453  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 23454  	Key   string `thrift:"key,2" db:"key" json:"key"`
 23455  	Index int64  `thrift:"index,3" db:"index" json:"index"`
 23456  	Value string `thrift:"value,4" db:"value" json:"value"`
 23457  }
 23458  
 23459  func NewLSetArgs() *LSetArgs {
 23460  	return &LSetArgs{}
 23461  }
 23462  
 23463  func (p *LSetArgs) GetAppid() string {
 23464  	return p.Appid
 23465  }
 23466  
 23467  func (p *LSetArgs) GetKey() string {
 23468  	return p.Key
 23469  }
 23470  
 23471  func (p *LSetArgs) GetIndex() int64 {
 23472  	return p.Index
 23473  }
 23474  
 23475  func (p *LSetArgs) GetValue() string {
 23476  	return p.Value
 23477  }
 23478  func (p *LSetArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 23479  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23480  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23481  	}
 23482  
 23483  	for {
 23484  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23485  		if err != nil {
 23486  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23487  		}
 23488  		if fieldTypeId == thrift.STOP {
 23489  			break
 23490  		}
 23491  		switch fieldId {
 23492  		case 1:
 23493  			if fieldTypeId == thrift.STRING {
 23494  				if err := p.ReadField1(ctx, tp); err != nil {
 23495  					return err
 23496  				}
 23497  			} else {
 23498  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23499  					return err
 23500  				}
 23501  			}
 23502  		case 2:
 23503  			if fieldTypeId == thrift.STRING {
 23504  				if err := p.ReadField2(ctx, tp); err != nil {
 23505  					return err
 23506  				}
 23507  			} else {
 23508  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23509  					return err
 23510  				}
 23511  			}
 23512  		case 3:
 23513  			if fieldTypeId == thrift.I64 {
 23514  				if err := p.ReadField3(ctx, tp); err != nil {
 23515  					return err
 23516  				}
 23517  			} else {
 23518  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23519  					return err
 23520  				}
 23521  			}
 23522  		case 4:
 23523  			if fieldTypeId == thrift.STRING {
 23524  				if err := p.ReadField4(ctx, tp); err != nil {
 23525  					return err
 23526  				}
 23527  			} else {
 23528  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23529  					return err
 23530  				}
 23531  			}
 23532  		default:
 23533  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23534  				return err
 23535  			}
 23536  		}
 23537  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23538  			return err
 23539  		}
 23540  	}
 23541  	if err := tp.ReadStructEnd(ctx); err != nil {
 23542  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23543  	}
 23544  	return nil
 23545  }
 23546  
 23547  func (p *LSetArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 23548  	if v, err := tp.ReadString(ctx); err != nil {
 23549  		return thrift.PrependError("error reading field 1: ", err)
 23550  	} else {
 23551  		p.Appid = v
 23552  	}
 23553  	return nil
 23554  }
 23555  
 23556  func (p *LSetArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 23557  	if v, err := tp.ReadString(ctx); err != nil {
 23558  		return thrift.PrependError("error reading field 2: ", err)
 23559  	} else {
 23560  		p.Key = v
 23561  	}
 23562  	return nil
 23563  }
 23564  
 23565  func (p *LSetArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 23566  	if v, err := tp.ReadI64(ctx); err != nil {
 23567  		return thrift.PrependError("error reading field 3: ", err)
 23568  	} else {
 23569  		p.Index = v
 23570  	}
 23571  	return nil
 23572  }
 23573  
 23574  func (p *LSetArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 23575  	if v, err := tp.ReadString(ctx); err != nil {
 23576  		return thrift.PrependError("error reading field 4: ", err)
 23577  	} else {
 23578  		p.Value = v
 23579  	}
 23580  	return nil
 23581  }
 23582  
 23583  func (p *LSetArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 23584  	if err := tp.WriteStructBegin(ctx, "LSet_args"); err != nil {
 23585  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23586  	}
 23587  	if p != nil {
 23588  		if err := p.writeField1(ctx, tp); err != nil {
 23589  			return err
 23590  		}
 23591  		if err := p.writeField2(ctx, tp); err != nil {
 23592  			return err
 23593  		}
 23594  		if err := p.writeField3(ctx, tp); err != nil {
 23595  			return err
 23596  		}
 23597  		if err := p.writeField4(ctx, tp); err != nil {
 23598  			return err
 23599  		}
 23600  	}
 23601  	if err := tp.WriteFieldStop(ctx); err != nil {
 23602  		return thrift.PrependError("write field stop error: ", err)
 23603  	}
 23604  	if err := tp.WriteStructEnd(ctx); err != nil {
 23605  		return thrift.PrependError("write struct stop error: ", err)
 23606  	}
 23607  	return nil
 23608  }
 23609  
 23610  func (p *LSetArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 23611  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 23612  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 23613  	}
 23614  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 23615  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 23616  	}
 23617  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23618  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 23619  	}
 23620  	return err
 23621  }
 23622  
 23623  func (p *LSetArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 23624  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 23625  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 23626  	}
 23627  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 23628  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 23629  	}
 23630  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23631  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 23632  	}
 23633  	return err
 23634  }
 23635  
 23636  func (p *LSetArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 23637  	if err := tp.WriteFieldBegin(ctx, "index", thrift.I64, 3); err != nil {
 23638  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:index: ", p), err)
 23639  	}
 23640  	if err := tp.WriteI64(ctx, int64(p.Index)); err != nil {
 23641  		return thrift.PrependError(fmt.Sprintf("%T.index (3) field write error: ", p), err)
 23642  	}
 23643  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23644  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:index: ", p), err)
 23645  	}
 23646  	return err
 23647  }
 23648  
 23649  func (p *LSetArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 23650  	if err := tp.WriteFieldBegin(ctx, "value", thrift.STRING, 4); err != nil {
 23651  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:value: ", p), err)
 23652  	}
 23653  	if err := tp.WriteString(ctx, string(p.Value)); err != nil {
 23654  		return thrift.PrependError(fmt.Sprintf("%T.value (4) field write error: ", p), err)
 23655  	}
 23656  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23657  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:value: ", p), err)
 23658  	}
 23659  	return err
 23660  }
 23661  
 23662  func (p *LSetArgs) String() string {
 23663  	if p == nil {
 23664  		return "<nil>"
 23665  	}
 23666  	return fmt.Sprintf("LSetArgs(%+v)", *p)
 23667  }
 23668  
 23669  // Attributes:
 23670  //  - Success
 23671  type LSetResult struct {
 23672  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 23673  }
 23674  
 23675  func NewLSetResult() *LSetResult {
 23676  	return &LSetResult{}
 23677  }
 23678  
 23679  var LSetResult_Success_DEFAULT *Response
 23680  
 23681  func (p *LSetResult) GetSuccess() *Response {
 23682  	if !p.IsSetSuccess() {
 23683  		return LSetResult_Success_DEFAULT
 23684  	}
 23685  	return p.Success
 23686  }
 23687  func (p *LSetResult) IsSetSuccess() bool {
 23688  	return p.Success != nil
 23689  }
 23690  
 23691  func (p *LSetResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 23692  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23693  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23694  	}
 23695  
 23696  	for {
 23697  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23698  		if err != nil {
 23699  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23700  		}
 23701  		if fieldTypeId == thrift.STOP {
 23702  			break
 23703  		}
 23704  		switch fieldId {
 23705  		case 0:
 23706  			if fieldTypeId == thrift.STRUCT {
 23707  				if err := p.ReadField0(ctx, tp); err != nil {
 23708  					return err
 23709  				}
 23710  			} else {
 23711  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23712  					return err
 23713  				}
 23714  			}
 23715  		default:
 23716  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23717  				return err
 23718  			}
 23719  		}
 23720  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23721  			return err
 23722  		}
 23723  	}
 23724  	if err := tp.ReadStructEnd(ctx); err != nil {
 23725  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23726  	}
 23727  	return nil
 23728  }
 23729  
 23730  func (p *LSetResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 23731  	p.Success = &Response{}
 23732  	if err := p.Success.Read(ctx, tp); err != nil {
 23733  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 23734  	}
 23735  	return nil
 23736  }
 23737  
 23738  func (p *LSetResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 23739  	if err := tp.WriteStructBegin(ctx, "LSet_result"); err != nil {
 23740  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23741  	}
 23742  	if p != nil {
 23743  		if err := p.writeField0(ctx, tp); err != nil {
 23744  			return err
 23745  		}
 23746  	}
 23747  	if err := tp.WriteFieldStop(ctx); err != nil {
 23748  		return thrift.PrependError("write field stop error: ", err)
 23749  	}
 23750  	if err := tp.WriteStructEnd(ctx); err != nil {
 23751  		return thrift.PrependError("write struct stop error: ", err)
 23752  	}
 23753  	return nil
 23754  }
 23755  
 23756  func (p *LSetResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 23757  	if p.IsSetSuccess() {
 23758  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 23759  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 23760  		}
 23761  		if err := p.Success.Write(ctx, tp); err != nil {
 23762  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 23763  		}
 23764  		if err := tp.WriteFieldEnd(ctx); err != nil {
 23765  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 23766  		}
 23767  	}
 23768  	return err
 23769  }
 23770  
 23771  func (p *LSetResult) String() string {
 23772  	if p == nil {
 23773  		return "<nil>"
 23774  	}
 23775  	return fmt.Sprintf("LSetResult(%+v)", *p)
 23776  }
 23777  
 23778  // Attributes:
 23779  //  - Appid
 23780  //  - Key
 23781  //  - Index
 23782  type LIndexArgs struct {
 23783  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 23784  	Key   string `thrift:"key,2" db:"key" json:"key"`
 23785  	Index int64  `thrift:"index,3" db:"index" json:"index"`
 23786  }
 23787  
 23788  func NewLIndexArgs() *LIndexArgs {
 23789  	return &LIndexArgs{}
 23790  }
 23791  
 23792  func (p *LIndexArgs) GetAppid() string {
 23793  	return p.Appid
 23794  }
 23795  
 23796  func (p *LIndexArgs) GetKey() string {
 23797  	return p.Key
 23798  }
 23799  
 23800  func (p *LIndexArgs) GetIndex() int64 {
 23801  	return p.Index
 23802  }
 23803  func (p *LIndexArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 23804  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23805  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23806  	}
 23807  
 23808  	for {
 23809  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23810  		if err != nil {
 23811  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23812  		}
 23813  		if fieldTypeId == thrift.STOP {
 23814  			break
 23815  		}
 23816  		switch fieldId {
 23817  		case 1:
 23818  			if fieldTypeId == thrift.STRING {
 23819  				if err := p.ReadField1(ctx, tp); err != nil {
 23820  					return err
 23821  				}
 23822  			} else {
 23823  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23824  					return err
 23825  				}
 23826  			}
 23827  		case 2:
 23828  			if fieldTypeId == thrift.STRING {
 23829  				if err := p.ReadField2(ctx, tp); err != nil {
 23830  					return err
 23831  				}
 23832  			} else {
 23833  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23834  					return err
 23835  				}
 23836  			}
 23837  		case 3:
 23838  			if fieldTypeId == thrift.I64 {
 23839  				if err := p.ReadField3(ctx, tp); err != nil {
 23840  					return err
 23841  				}
 23842  			} else {
 23843  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23844  					return err
 23845  				}
 23846  			}
 23847  		default:
 23848  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 23849  				return err
 23850  			}
 23851  		}
 23852  		if err := tp.ReadFieldEnd(ctx); err != nil {
 23853  			return err
 23854  		}
 23855  	}
 23856  	if err := tp.ReadStructEnd(ctx); err != nil {
 23857  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 23858  	}
 23859  	return nil
 23860  }
 23861  
 23862  func (p *LIndexArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 23863  	if v, err := tp.ReadString(ctx); err != nil {
 23864  		return thrift.PrependError("error reading field 1: ", err)
 23865  	} else {
 23866  		p.Appid = v
 23867  	}
 23868  	return nil
 23869  }
 23870  
 23871  func (p *LIndexArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 23872  	if v, err := tp.ReadString(ctx); err != nil {
 23873  		return thrift.PrependError("error reading field 2: ", err)
 23874  	} else {
 23875  		p.Key = v
 23876  	}
 23877  	return nil
 23878  }
 23879  
 23880  func (p *LIndexArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 23881  	if v, err := tp.ReadI64(ctx); err != nil {
 23882  		return thrift.PrependError("error reading field 3: ", err)
 23883  	} else {
 23884  		p.Index = v
 23885  	}
 23886  	return nil
 23887  }
 23888  
 23889  func (p *LIndexArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 23890  	if err := tp.WriteStructBegin(ctx, "LIndex_args"); err != nil {
 23891  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 23892  	}
 23893  	if p != nil {
 23894  		if err := p.writeField1(ctx, tp); err != nil {
 23895  			return err
 23896  		}
 23897  		if err := p.writeField2(ctx, tp); err != nil {
 23898  			return err
 23899  		}
 23900  		if err := p.writeField3(ctx, tp); err != nil {
 23901  			return err
 23902  		}
 23903  	}
 23904  	if err := tp.WriteFieldStop(ctx); err != nil {
 23905  		return thrift.PrependError("write field stop error: ", err)
 23906  	}
 23907  	if err := tp.WriteStructEnd(ctx); err != nil {
 23908  		return thrift.PrependError("write struct stop error: ", err)
 23909  	}
 23910  	return nil
 23911  }
 23912  
 23913  func (p *LIndexArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 23914  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 23915  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 23916  	}
 23917  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 23918  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 23919  	}
 23920  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23921  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 23922  	}
 23923  	return err
 23924  }
 23925  
 23926  func (p *LIndexArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 23927  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 23928  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 23929  	}
 23930  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 23931  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 23932  	}
 23933  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23934  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 23935  	}
 23936  	return err
 23937  }
 23938  
 23939  func (p *LIndexArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 23940  	if err := tp.WriteFieldBegin(ctx, "index", thrift.I64, 3); err != nil {
 23941  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:index: ", p), err)
 23942  	}
 23943  	if err := tp.WriteI64(ctx, int64(p.Index)); err != nil {
 23944  		return thrift.PrependError(fmt.Sprintf("%T.index (3) field write error: ", p), err)
 23945  	}
 23946  	if err := tp.WriteFieldEnd(ctx); err != nil {
 23947  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:index: ", p), err)
 23948  	}
 23949  	return err
 23950  }
 23951  
 23952  func (p *LIndexArgs) String() string {
 23953  	if p == nil {
 23954  		return "<nil>"
 23955  	}
 23956  	return fmt.Sprintf("LIndexArgs(%+v)", *p)
 23957  }
 23958  
 23959  // Attributes:
 23960  //  - Success
 23961  type LIndexResult struct {
 23962  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 23963  }
 23964  
 23965  func NewLIndexResult() *LIndexResult {
 23966  	return &LIndexResult{}
 23967  }
 23968  
 23969  var LIndexResult_Success_DEFAULT *Response
 23970  
 23971  func (p *LIndexResult) GetSuccess() *Response {
 23972  	if !p.IsSetSuccess() {
 23973  		return LIndexResult_Success_DEFAULT
 23974  	}
 23975  	return p.Success
 23976  }
 23977  func (p *LIndexResult) IsSetSuccess() bool {
 23978  	return p.Success != nil
 23979  }
 23980  
 23981  func (p *LIndexResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 23982  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 23983  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 23984  	}
 23985  
 23986  	for {
 23987  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 23988  		if err != nil {
 23989  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 23990  		}
 23991  		if fieldTypeId == thrift.STOP {
 23992  			break
 23993  		}
 23994  		switch fieldId {
 23995  		case 0:
 23996  			if fieldTypeId == thrift.STRUCT {
 23997  				if err := p.ReadField0(ctx, tp); err != nil {
 23998  					return err
 23999  				}
 24000  			} else {
 24001  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24002  					return err
 24003  				}
 24004  			}
 24005  		default:
 24006  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24007  				return err
 24008  			}
 24009  		}
 24010  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24011  			return err
 24012  		}
 24013  	}
 24014  	if err := tp.ReadStructEnd(ctx); err != nil {
 24015  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24016  	}
 24017  	return nil
 24018  }
 24019  
 24020  func (p *LIndexResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 24021  	p.Success = &Response{}
 24022  	if err := p.Success.Read(ctx, tp); err != nil {
 24023  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 24024  	}
 24025  	return nil
 24026  }
 24027  
 24028  func (p *LIndexResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 24029  	if err := tp.WriteStructBegin(ctx, "LIndex_result"); err != nil {
 24030  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24031  	}
 24032  	if p != nil {
 24033  		if err := p.writeField0(ctx, tp); err != nil {
 24034  			return err
 24035  		}
 24036  	}
 24037  	if err := tp.WriteFieldStop(ctx); err != nil {
 24038  		return thrift.PrependError("write field stop error: ", err)
 24039  	}
 24040  	if err := tp.WriteStructEnd(ctx); err != nil {
 24041  		return thrift.PrependError("write struct stop error: ", err)
 24042  	}
 24043  	return nil
 24044  }
 24045  
 24046  func (p *LIndexResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 24047  	if p.IsSetSuccess() {
 24048  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 24049  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 24050  		}
 24051  		if err := p.Success.Write(ctx, tp); err != nil {
 24052  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 24053  		}
 24054  		if err := tp.WriteFieldEnd(ctx); err != nil {
 24055  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 24056  		}
 24057  	}
 24058  	return err
 24059  }
 24060  
 24061  func (p *LIndexResult) String() string {
 24062  	if p == nil {
 24063  		return "<nil>"
 24064  	}
 24065  	return fmt.Sprintf("LIndexResult(%+v)", *p)
 24066  }
 24067  
 24068  // Attributes:
 24069  //  - Appid
 24070  //  - Key
 24071  //  - Start
 24072  //  - Stop
 24073  type LRangeArgs struct {
 24074  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 24075  	Key   string `thrift:"key,2" db:"key" json:"key"`
 24076  	Start int64  `thrift:"start,3" db:"start" json:"start"`
 24077  	Stop  int64  `thrift:"stop,4" db:"stop" json:"stop"`
 24078  }
 24079  
 24080  func NewLRangeArgs() *LRangeArgs {
 24081  	return &LRangeArgs{}
 24082  }
 24083  
 24084  func (p *LRangeArgs) GetAppid() string {
 24085  	return p.Appid
 24086  }
 24087  
 24088  func (p *LRangeArgs) GetKey() string {
 24089  	return p.Key
 24090  }
 24091  
 24092  func (p *LRangeArgs) GetStart() int64 {
 24093  	return p.Start
 24094  }
 24095  
 24096  func (p *LRangeArgs) GetStop() int64 {
 24097  	return p.Stop
 24098  }
 24099  func (p *LRangeArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 24100  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24101  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24102  	}
 24103  
 24104  	for {
 24105  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24106  		if err != nil {
 24107  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24108  		}
 24109  		if fieldTypeId == thrift.STOP {
 24110  			break
 24111  		}
 24112  		switch fieldId {
 24113  		case 1:
 24114  			if fieldTypeId == thrift.STRING {
 24115  				if err := p.ReadField1(ctx, tp); err != nil {
 24116  					return err
 24117  				}
 24118  			} else {
 24119  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24120  					return err
 24121  				}
 24122  			}
 24123  		case 2:
 24124  			if fieldTypeId == thrift.STRING {
 24125  				if err := p.ReadField2(ctx, tp); err != nil {
 24126  					return err
 24127  				}
 24128  			} else {
 24129  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24130  					return err
 24131  				}
 24132  			}
 24133  		case 3:
 24134  			if fieldTypeId == thrift.I64 {
 24135  				if err := p.ReadField3(ctx, tp); err != nil {
 24136  					return err
 24137  				}
 24138  			} else {
 24139  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24140  					return err
 24141  				}
 24142  			}
 24143  		case 4:
 24144  			if fieldTypeId == thrift.I64 {
 24145  				if err := p.ReadField4(ctx, tp); err != nil {
 24146  					return err
 24147  				}
 24148  			} else {
 24149  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24150  					return err
 24151  				}
 24152  			}
 24153  		default:
 24154  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24155  				return err
 24156  			}
 24157  		}
 24158  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24159  			return err
 24160  		}
 24161  	}
 24162  	if err := tp.ReadStructEnd(ctx); err != nil {
 24163  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24164  	}
 24165  	return nil
 24166  }
 24167  
 24168  func (p *LRangeArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 24169  	if v, err := tp.ReadString(ctx); err != nil {
 24170  		return thrift.PrependError("error reading field 1: ", err)
 24171  	} else {
 24172  		p.Appid = v
 24173  	}
 24174  	return nil
 24175  }
 24176  
 24177  func (p *LRangeArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 24178  	if v, err := tp.ReadString(ctx); err != nil {
 24179  		return thrift.PrependError("error reading field 2: ", err)
 24180  	} else {
 24181  		p.Key = v
 24182  	}
 24183  	return nil
 24184  }
 24185  
 24186  func (p *LRangeArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 24187  	if v, err := tp.ReadI64(ctx); err != nil {
 24188  		return thrift.PrependError("error reading field 3: ", err)
 24189  	} else {
 24190  		p.Start = v
 24191  	}
 24192  	return nil
 24193  }
 24194  
 24195  func (p *LRangeArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 24196  	if v, err := tp.ReadI64(ctx); err != nil {
 24197  		return thrift.PrependError("error reading field 4: ", err)
 24198  	} else {
 24199  		p.Stop = v
 24200  	}
 24201  	return nil
 24202  }
 24203  
 24204  func (p *LRangeArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 24205  	if err := tp.WriteStructBegin(ctx, "LRange_args"); err != nil {
 24206  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24207  	}
 24208  	if p != nil {
 24209  		if err := p.writeField1(ctx, tp); err != nil {
 24210  			return err
 24211  		}
 24212  		if err := p.writeField2(ctx, tp); err != nil {
 24213  			return err
 24214  		}
 24215  		if err := p.writeField3(ctx, tp); err != nil {
 24216  			return err
 24217  		}
 24218  		if err := p.writeField4(ctx, tp); err != nil {
 24219  			return err
 24220  		}
 24221  	}
 24222  	if err := tp.WriteFieldStop(ctx); err != nil {
 24223  		return thrift.PrependError("write field stop error: ", err)
 24224  	}
 24225  	if err := tp.WriteStructEnd(ctx); err != nil {
 24226  		return thrift.PrependError("write struct stop error: ", err)
 24227  	}
 24228  	return nil
 24229  }
 24230  
 24231  func (p *LRangeArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 24232  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 24233  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 24234  	}
 24235  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 24236  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 24237  	}
 24238  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24239  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 24240  	}
 24241  	return err
 24242  }
 24243  
 24244  func (p *LRangeArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 24245  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 24246  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 24247  	}
 24248  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 24249  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 24250  	}
 24251  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24252  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 24253  	}
 24254  	return err
 24255  }
 24256  
 24257  func (p *LRangeArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 24258  	if err := tp.WriteFieldBegin(ctx, "start", thrift.I64, 3); err != nil {
 24259  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:start: ", p), err)
 24260  	}
 24261  	if err := tp.WriteI64(ctx, int64(p.Start)); err != nil {
 24262  		return thrift.PrependError(fmt.Sprintf("%T.start (3) field write error: ", p), err)
 24263  	}
 24264  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24265  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:start: ", p), err)
 24266  	}
 24267  	return err
 24268  }
 24269  
 24270  func (p *LRangeArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 24271  	if err := tp.WriteFieldBegin(ctx, "stop", thrift.I64, 4); err != nil {
 24272  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:stop: ", p), err)
 24273  	}
 24274  	if err := tp.WriteI64(ctx, int64(p.Stop)); err != nil {
 24275  		return thrift.PrependError(fmt.Sprintf("%T.stop (4) field write error: ", p), err)
 24276  	}
 24277  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24278  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:stop: ", p), err)
 24279  	}
 24280  	return err
 24281  }
 24282  
 24283  func (p *LRangeArgs) String() string {
 24284  	if p == nil {
 24285  		return "<nil>"
 24286  	}
 24287  	return fmt.Sprintf("LRangeArgs(%+v)", *p)
 24288  }
 24289  
 24290  // Attributes:
 24291  //  - Success
 24292  type LRangeResult struct {
 24293  	Success *LResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 24294  }
 24295  
 24296  func NewLRangeResult() *LRangeResult {
 24297  	return &LRangeResult{}
 24298  }
 24299  
 24300  var LRangeResult_Success_DEFAULT *LResponse
 24301  
 24302  func (p *LRangeResult) GetSuccess() *LResponse {
 24303  	if !p.IsSetSuccess() {
 24304  		return LRangeResult_Success_DEFAULT
 24305  	}
 24306  	return p.Success
 24307  }
 24308  func (p *LRangeResult) IsSetSuccess() bool {
 24309  	return p.Success != nil
 24310  }
 24311  
 24312  func (p *LRangeResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 24313  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24314  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24315  	}
 24316  
 24317  	for {
 24318  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24319  		if err != nil {
 24320  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24321  		}
 24322  		if fieldTypeId == thrift.STOP {
 24323  			break
 24324  		}
 24325  		switch fieldId {
 24326  		case 0:
 24327  			if fieldTypeId == thrift.STRUCT {
 24328  				if err := p.ReadField0(ctx, tp); err != nil {
 24329  					return err
 24330  				}
 24331  			} else {
 24332  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24333  					return err
 24334  				}
 24335  			}
 24336  		default:
 24337  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24338  				return err
 24339  			}
 24340  		}
 24341  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24342  			return err
 24343  		}
 24344  	}
 24345  	if err := tp.ReadStructEnd(ctx); err != nil {
 24346  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24347  	}
 24348  	return nil
 24349  }
 24350  
 24351  func (p *LRangeResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 24352  	p.Success = &LResponse{}
 24353  	if err := p.Success.Read(ctx, tp); err != nil {
 24354  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 24355  	}
 24356  	return nil
 24357  }
 24358  
 24359  func (p *LRangeResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 24360  	if err := tp.WriteStructBegin(ctx, "LRange_result"); err != nil {
 24361  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24362  	}
 24363  	if p != nil {
 24364  		if err := p.writeField0(ctx, tp); err != nil {
 24365  			return err
 24366  		}
 24367  	}
 24368  	if err := tp.WriteFieldStop(ctx); err != nil {
 24369  		return thrift.PrependError("write field stop error: ", err)
 24370  	}
 24371  	if err := tp.WriteStructEnd(ctx); err != nil {
 24372  		return thrift.PrependError("write struct stop error: ", err)
 24373  	}
 24374  	return nil
 24375  }
 24376  
 24377  func (p *LRangeResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 24378  	if p.IsSetSuccess() {
 24379  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 24380  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 24381  		}
 24382  		if err := p.Success.Write(ctx, tp); err != nil {
 24383  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 24384  		}
 24385  		if err := tp.WriteFieldEnd(ctx); err != nil {
 24386  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 24387  		}
 24388  	}
 24389  	return err
 24390  }
 24391  
 24392  func (p *LRangeResult) String() string {
 24393  	if p == nil {
 24394  		return "<nil>"
 24395  	}
 24396  	return fmt.Sprintf("LRangeResult(%+v)", *p)
 24397  }
 24398  
 24399  // Attributes:
 24400  //  - Appid
 24401  //  - Key
 24402  //  - Start
 24403  //  - Stop
 24404  type LTrimArgs struct {
 24405  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 24406  	Key   string `thrift:"key,2" db:"key" json:"key"`
 24407  	Start int64  `thrift:"start,3" db:"start" json:"start"`
 24408  	Stop  int64  `thrift:"stop,4" db:"stop" json:"stop"`
 24409  }
 24410  
 24411  func NewLTrimArgs() *LTrimArgs {
 24412  	return &LTrimArgs{}
 24413  }
 24414  
 24415  func (p *LTrimArgs) GetAppid() string {
 24416  	return p.Appid
 24417  }
 24418  
 24419  func (p *LTrimArgs) GetKey() string {
 24420  	return p.Key
 24421  }
 24422  
 24423  func (p *LTrimArgs) GetStart() int64 {
 24424  	return p.Start
 24425  }
 24426  
 24427  func (p *LTrimArgs) GetStop() int64 {
 24428  	return p.Stop
 24429  }
 24430  func (p *LTrimArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 24431  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24432  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24433  	}
 24434  
 24435  	for {
 24436  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24437  		if err != nil {
 24438  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24439  		}
 24440  		if fieldTypeId == thrift.STOP {
 24441  			break
 24442  		}
 24443  		switch fieldId {
 24444  		case 1:
 24445  			if fieldTypeId == thrift.STRING {
 24446  				if err := p.ReadField1(ctx, tp); err != nil {
 24447  					return err
 24448  				}
 24449  			} else {
 24450  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24451  					return err
 24452  				}
 24453  			}
 24454  		case 2:
 24455  			if fieldTypeId == thrift.STRING {
 24456  				if err := p.ReadField2(ctx, tp); err != nil {
 24457  					return err
 24458  				}
 24459  			} else {
 24460  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24461  					return err
 24462  				}
 24463  			}
 24464  		case 3:
 24465  			if fieldTypeId == thrift.I64 {
 24466  				if err := p.ReadField3(ctx, tp); err != nil {
 24467  					return err
 24468  				}
 24469  			} else {
 24470  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24471  					return err
 24472  				}
 24473  			}
 24474  		case 4:
 24475  			if fieldTypeId == thrift.I64 {
 24476  				if err := p.ReadField4(ctx, tp); err != nil {
 24477  					return err
 24478  				}
 24479  			} else {
 24480  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24481  					return err
 24482  				}
 24483  			}
 24484  		default:
 24485  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24486  				return err
 24487  			}
 24488  		}
 24489  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24490  			return err
 24491  		}
 24492  	}
 24493  	if err := tp.ReadStructEnd(ctx); err != nil {
 24494  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24495  	}
 24496  	return nil
 24497  }
 24498  
 24499  func (p *LTrimArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 24500  	if v, err := tp.ReadString(ctx); err != nil {
 24501  		return thrift.PrependError("error reading field 1: ", err)
 24502  	} else {
 24503  		p.Appid = v
 24504  	}
 24505  	return nil
 24506  }
 24507  
 24508  func (p *LTrimArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 24509  	if v, err := tp.ReadString(ctx); err != nil {
 24510  		return thrift.PrependError("error reading field 2: ", err)
 24511  	} else {
 24512  		p.Key = v
 24513  	}
 24514  	return nil
 24515  }
 24516  
 24517  func (p *LTrimArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 24518  	if v, err := tp.ReadI64(ctx); err != nil {
 24519  		return thrift.PrependError("error reading field 3: ", err)
 24520  	} else {
 24521  		p.Start = v
 24522  	}
 24523  	return nil
 24524  }
 24525  
 24526  func (p *LTrimArgs) ReadField4(ctx context.Context, tp thrift.TProtocol) error {
 24527  	if v, err := tp.ReadI64(ctx); err != nil {
 24528  		return thrift.PrependError("error reading field 4: ", err)
 24529  	} else {
 24530  		p.Stop = v
 24531  	}
 24532  	return nil
 24533  }
 24534  
 24535  func (p *LTrimArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 24536  	if err := tp.WriteStructBegin(ctx, "LTrim_args"); err != nil {
 24537  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24538  	}
 24539  	if p != nil {
 24540  		if err := p.writeField1(ctx, tp); err != nil {
 24541  			return err
 24542  		}
 24543  		if err := p.writeField2(ctx, tp); err != nil {
 24544  			return err
 24545  		}
 24546  		if err := p.writeField3(ctx, tp); err != nil {
 24547  			return err
 24548  		}
 24549  		if err := p.writeField4(ctx, tp); err != nil {
 24550  			return err
 24551  		}
 24552  	}
 24553  	if err := tp.WriteFieldStop(ctx); err != nil {
 24554  		return thrift.PrependError("write field stop error: ", err)
 24555  	}
 24556  	if err := tp.WriteStructEnd(ctx); err != nil {
 24557  		return thrift.PrependError("write struct stop error: ", err)
 24558  	}
 24559  	return nil
 24560  }
 24561  
 24562  func (p *LTrimArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 24563  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 24564  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 24565  	}
 24566  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 24567  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 24568  	}
 24569  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24570  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 24571  	}
 24572  	return err
 24573  }
 24574  
 24575  func (p *LTrimArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 24576  	if err := tp.WriteFieldBegin(ctx, "key", thrift.STRING, 2); err != nil {
 24577  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:key: ", p), err)
 24578  	}
 24579  	if err := tp.WriteString(ctx, string(p.Key)); err != nil {
 24580  		return thrift.PrependError(fmt.Sprintf("%T.key (2) field write error: ", p), err)
 24581  	}
 24582  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24583  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:key: ", p), err)
 24584  	}
 24585  	return err
 24586  }
 24587  
 24588  func (p *LTrimArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 24589  	if err := tp.WriteFieldBegin(ctx, "start", thrift.I64, 3); err != nil {
 24590  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:start: ", p), err)
 24591  	}
 24592  	if err := tp.WriteI64(ctx, int64(p.Start)); err != nil {
 24593  		return thrift.PrependError(fmt.Sprintf("%T.start (3) field write error: ", p), err)
 24594  	}
 24595  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24596  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:start: ", p), err)
 24597  	}
 24598  	return err
 24599  }
 24600  
 24601  func (p *LTrimArgs) writeField4(ctx context.Context, tp thrift.TProtocol) (err error) {
 24602  	if err := tp.WriteFieldBegin(ctx, "stop", thrift.I64, 4); err != nil {
 24603  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:stop: ", p), err)
 24604  	}
 24605  	if err := tp.WriteI64(ctx, int64(p.Stop)); err != nil {
 24606  		return thrift.PrependError(fmt.Sprintf("%T.stop (4) field write error: ", p), err)
 24607  	}
 24608  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24609  		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:stop: ", p), err)
 24610  	}
 24611  	return err
 24612  }
 24613  
 24614  func (p *LTrimArgs) String() string {
 24615  	if p == nil {
 24616  		return "<nil>"
 24617  	}
 24618  	return fmt.Sprintf("LTrimArgs(%+v)", *p)
 24619  }
 24620  
 24621  // Attributes:
 24622  //  - Success
 24623  type LTrimResult struct {
 24624  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 24625  }
 24626  
 24627  func NewLTrimResult() *LTrimResult {
 24628  	return &LTrimResult{}
 24629  }
 24630  
 24631  var LTrimResult_Success_DEFAULT *Response
 24632  
 24633  func (p *LTrimResult) GetSuccess() *Response {
 24634  	if !p.IsSetSuccess() {
 24635  		return LTrimResult_Success_DEFAULT
 24636  	}
 24637  	return p.Success
 24638  }
 24639  func (p *LTrimResult) IsSetSuccess() bool {
 24640  	return p.Success != nil
 24641  }
 24642  
 24643  func (p *LTrimResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 24644  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24645  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24646  	}
 24647  
 24648  	for {
 24649  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24650  		if err != nil {
 24651  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24652  		}
 24653  		if fieldTypeId == thrift.STOP {
 24654  			break
 24655  		}
 24656  		switch fieldId {
 24657  		case 0:
 24658  			if fieldTypeId == thrift.STRUCT {
 24659  				if err := p.ReadField0(ctx, tp); err != nil {
 24660  					return err
 24661  				}
 24662  			} else {
 24663  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24664  					return err
 24665  				}
 24666  			}
 24667  		default:
 24668  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24669  				return err
 24670  			}
 24671  		}
 24672  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24673  			return err
 24674  		}
 24675  	}
 24676  	if err := tp.ReadStructEnd(ctx); err != nil {
 24677  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24678  	}
 24679  	return nil
 24680  }
 24681  
 24682  func (p *LTrimResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 24683  	p.Success = &Response{}
 24684  	if err := p.Success.Read(ctx, tp); err != nil {
 24685  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 24686  	}
 24687  	return nil
 24688  }
 24689  
 24690  func (p *LTrimResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 24691  	if err := tp.WriteStructBegin(ctx, "LTrim_result"); err != nil {
 24692  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24693  	}
 24694  	if p != nil {
 24695  		if err := p.writeField0(ctx, tp); err != nil {
 24696  			return err
 24697  		}
 24698  	}
 24699  	if err := tp.WriteFieldStop(ctx); err != nil {
 24700  		return thrift.PrependError("write field stop error: ", err)
 24701  	}
 24702  	if err := tp.WriteStructEnd(ctx); err != nil {
 24703  		return thrift.PrependError("write struct stop error: ", err)
 24704  	}
 24705  	return nil
 24706  }
 24707  
 24708  func (p *LTrimResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 24709  	if p.IsSetSuccess() {
 24710  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 24711  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 24712  		}
 24713  		if err := p.Success.Write(ctx, tp); err != nil {
 24714  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 24715  		}
 24716  		if err := tp.WriteFieldEnd(ctx); err != nil {
 24717  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 24718  		}
 24719  	}
 24720  	return err
 24721  }
 24722  
 24723  func (p *LTrimResult) String() string {
 24724  	if p == nil {
 24725  		return "<nil>"
 24726  	}
 24727  	return fmt.Sprintf("LTrimResult(%+v)", *p)
 24728  }
 24729  
 24730  // Attributes:
 24731  //  - Appid
 24732  type ClusterNodesArgs struct {
 24733  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 24734  }
 24735  
 24736  func NewClusterNodesArgs() *ClusterNodesArgs {
 24737  	return &ClusterNodesArgs{}
 24738  }
 24739  
 24740  func (p *ClusterNodesArgs) GetAppid() string {
 24741  	return p.Appid
 24742  }
 24743  func (p *ClusterNodesArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 24744  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24745  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24746  	}
 24747  
 24748  	for {
 24749  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24750  		if err != nil {
 24751  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24752  		}
 24753  		if fieldTypeId == thrift.STOP {
 24754  			break
 24755  		}
 24756  		switch fieldId {
 24757  		case 1:
 24758  			if fieldTypeId == thrift.STRING {
 24759  				if err := p.ReadField1(ctx, tp); err != nil {
 24760  					return err
 24761  				}
 24762  			} else {
 24763  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24764  					return err
 24765  				}
 24766  			}
 24767  		default:
 24768  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24769  				return err
 24770  			}
 24771  		}
 24772  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24773  			return err
 24774  		}
 24775  	}
 24776  	if err := tp.ReadStructEnd(ctx); err != nil {
 24777  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24778  	}
 24779  	return nil
 24780  }
 24781  
 24782  func (p *ClusterNodesArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 24783  	if v, err := tp.ReadString(ctx); err != nil {
 24784  		return thrift.PrependError("error reading field 1: ", err)
 24785  	} else {
 24786  		p.Appid = v
 24787  	}
 24788  	return nil
 24789  }
 24790  
 24791  func (p *ClusterNodesArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 24792  	if err := tp.WriteStructBegin(ctx, "ClusterNodes_args"); err != nil {
 24793  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24794  	}
 24795  	if p != nil {
 24796  		if err := p.writeField1(ctx, tp); err != nil {
 24797  			return err
 24798  		}
 24799  	}
 24800  	if err := tp.WriteFieldStop(ctx); err != nil {
 24801  		return thrift.PrependError("write field stop error: ", err)
 24802  	}
 24803  	if err := tp.WriteStructEnd(ctx); err != nil {
 24804  		return thrift.PrependError("write struct stop error: ", err)
 24805  	}
 24806  	return nil
 24807  }
 24808  
 24809  func (p *ClusterNodesArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 24810  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 24811  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 24812  	}
 24813  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 24814  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 24815  	}
 24816  	if err := tp.WriteFieldEnd(ctx); err != nil {
 24817  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 24818  	}
 24819  	return err
 24820  }
 24821  
 24822  func (p *ClusterNodesArgs) String() string {
 24823  	if p == nil {
 24824  		return "<nil>"
 24825  	}
 24826  	return fmt.Sprintf("ClusterNodesArgs(%+v)", *p)
 24827  }
 24828  
 24829  // Attributes:
 24830  //  - Success
 24831  type ClusterNodesResult struct {
 24832  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 24833  }
 24834  
 24835  func NewClusterNodesResult() *ClusterNodesResult {
 24836  	return &ClusterNodesResult{}
 24837  }
 24838  
 24839  var ClusterNodesResult_Success_DEFAULT *Response
 24840  
 24841  func (p *ClusterNodesResult) GetSuccess() *Response {
 24842  	if !p.IsSetSuccess() {
 24843  		return ClusterNodesResult_Success_DEFAULT
 24844  	}
 24845  	return p.Success
 24846  }
 24847  func (p *ClusterNodesResult) IsSetSuccess() bool {
 24848  	return p.Success != nil
 24849  }
 24850  
 24851  func (p *ClusterNodesResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 24852  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24853  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24854  	}
 24855  
 24856  	for {
 24857  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24858  		if err != nil {
 24859  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24860  		}
 24861  		if fieldTypeId == thrift.STOP {
 24862  			break
 24863  		}
 24864  		switch fieldId {
 24865  		case 0:
 24866  			if fieldTypeId == thrift.STRUCT {
 24867  				if err := p.ReadField0(ctx, tp); err != nil {
 24868  					return err
 24869  				}
 24870  			} else {
 24871  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24872  					return err
 24873  				}
 24874  			}
 24875  		default:
 24876  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24877  				return err
 24878  			}
 24879  		}
 24880  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24881  			return err
 24882  		}
 24883  	}
 24884  	if err := tp.ReadStructEnd(ctx); err != nil {
 24885  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24886  	}
 24887  	return nil
 24888  }
 24889  
 24890  func (p *ClusterNodesResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 24891  	p.Success = &Response{}
 24892  	if err := p.Success.Read(ctx, tp); err != nil {
 24893  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 24894  	}
 24895  	return nil
 24896  }
 24897  
 24898  func (p *ClusterNodesResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 24899  	if err := tp.WriteStructBegin(ctx, "ClusterNodes_result"); err != nil {
 24900  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 24901  	}
 24902  	if p != nil {
 24903  		if err := p.writeField0(ctx, tp); err != nil {
 24904  			return err
 24905  		}
 24906  	}
 24907  	if err := tp.WriteFieldStop(ctx); err != nil {
 24908  		return thrift.PrependError("write field stop error: ", err)
 24909  	}
 24910  	if err := tp.WriteStructEnd(ctx); err != nil {
 24911  		return thrift.PrependError("write struct stop error: ", err)
 24912  	}
 24913  	return nil
 24914  }
 24915  
 24916  func (p *ClusterNodesResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 24917  	if p.IsSetSuccess() {
 24918  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 24919  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 24920  		}
 24921  		if err := p.Success.Write(ctx, tp); err != nil {
 24922  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 24923  		}
 24924  		if err := tp.WriteFieldEnd(ctx); err != nil {
 24925  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 24926  		}
 24927  	}
 24928  	return err
 24929  }
 24930  
 24931  func (p *ClusterNodesResult) String() string {
 24932  	if p == nil {
 24933  		return "<nil>"
 24934  	}
 24935  	return fmt.Sprintf("ClusterNodesResult(%+v)", *p)
 24936  }
 24937  
 24938  // Attributes:
 24939  //  - Appid
 24940  type ClusterInfoArgs struct {
 24941  	Appid string `thrift:"appid,1" db:"appid" json:"appid"`
 24942  }
 24943  
 24944  func NewClusterInfoArgs() *ClusterInfoArgs {
 24945  	return &ClusterInfoArgs{}
 24946  }
 24947  
 24948  func (p *ClusterInfoArgs) GetAppid() string {
 24949  	return p.Appid
 24950  }
 24951  func (p *ClusterInfoArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 24952  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 24953  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 24954  	}
 24955  
 24956  	for {
 24957  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 24958  		if err != nil {
 24959  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 24960  		}
 24961  		if fieldTypeId == thrift.STOP {
 24962  			break
 24963  		}
 24964  		switch fieldId {
 24965  		case 1:
 24966  			if fieldTypeId == thrift.STRING {
 24967  				if err := p.ReadField1(ctx, tp); err != nil {
 24968  					return err
 24969  				}
 24970  			} else {
 24971  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24972  					return err
 24973  				}
 24974  			}
 24975  		default:
 24976  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 24977  				return err
 24978  			}
 24979  		}
 24980  		if err := tp.ReadFieldEnd(ctx); err != nil {
 24981  			return err
 24982  		}
 24983  	}
 24984  	if err := tp.ReadStructEnd(ctx); err != nil {
 24985  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 24986  	}
 24987  	return nil
 24988  }
 24989  
 24990  func (p *ClusterInfoArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 24991  	if v, err := tp.ReadString(ctx); err != nil {
 24992  		return thrift.PrependError("error reading field 1: ", err)
 24993  	} else {
 24994  		p.Appid = v
 24995  	}
 24996  	return nil
 24997  }
 24998  
 24999  func (p *ClusterInfoArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 25000  	if err := tp.WriteStructBegin(ctx, "ClusterInfo_args"); err != nil {
 25001  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25002  	}
 25003  	if p != nil {
 25004  		if err := p.writeField1(ctx, tp); err != nil {
 25005  			return err
 25006  		}
 25007  	}
 25008  	if err := tp.WriteFieldStop(ctx); err != nil {
 25009  		return thrift.PrependError("write field stop error: ", err)
 25010  	}
 25011  	if err := tp.WriteStructEnd(ctx); err != nil {
 25012  		return thrift.PrependError("write struct stop error: ", err)
 25013  	}
 25014  	return nil
 25015  }
 25016  
 25017  func (p *ClusterInfoArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 25018  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 25019  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 25020  	}
 25021  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 25022  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 25023  	}
 25024  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25025  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 25026  	}
 25027  	return err
 25028  }
 25029  
 25030  func (p *ClusterInfoArgs) String() string {
 25031  	if p == nil {
 25032  		return "<nil>"
 25033  	}
 25034  	return fmt.Sprintf("ClusterInfoArgs(%+v)", *p)
 25035  }
 25036  
 25037  // Attributes:
 25038  //  - Success
 25039  type ClusterInfoResult struct {
 25040  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 25041  }
 25042  
 25043  func NewClusterInfoResult() *ClusterInfoResult {
 25044  	return &ClusterInfoResult{}
 25045  }
 25046  
 25047  var ClusterInfoResult_Success_DEFAULT *Response
 25048  
 25049  func (p *ClusterInfoResult) GetSuccess() *Response {
 25050  	if !p.IsSetSuccess() {
 25051  		return ClusterInfoResult_Success_DEFAULT
 25052  	}
 25053  	return p.Success
 25054  }
 25055  func (p *ClusterInfoResult) IsSetSuccess() bool {
 25056  	return p.Success != nil
 25057  }
 25058  
 25059  func (p *ClusterInfoResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 25060  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 25061  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 25062  	}
 25063  
 25064  	for {
 25065  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 25066  		if err != nil {
 25067  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 25068  		}
 25069  		if fieldTypeId == thrift.STOP {
 25070  			break
 25071  		}
 25072  		switch fieldId {
 25073  		case 0:
 25074  			if fieldTypeId == thrift.STRUCT {
 25075  				if err := p.ReadField0(ctx, tp); err != nil {
 25076  					return err
 25077  				}
 25078  			} else {
 25079  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25080  					return err
 25081  				}
 25082  			}
 25083  		default:
 25084  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25085  				return err
 25086  			}
 25087  		}
 25088  		if err := tp.ReadFieldEnd(ctx); err != nil {
 25089  			return err
 25090  		}
 25091  	}
 25092  	if err := tp.ReadStructEnd(ctx); err != nil {
 25093  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 25094  	}
 25095  	return nil
 25096  }
 25097  
 25098  func (p *ClusterInfoResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 25099  	p.Success = &Response{}
 25100  	if err := p.Success.Read(ctx, tp); err != nil {
 25101  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 25102  	}
 25103  	return nil
 25104  }
 25105  
 25106  func (p *ClusterInfoResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 25107  	if err := tp.WriteStructBegin(ctx, "ClusterInfo_result"); err != nil {
 25108  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25109  	}
 25110  	if p != nil {
 25111  		if err := p.writeField0(ctx, tp); err != nil {
 25112  			return err
 25113  		}
 25114  	}
 25115  	if err := tp.WriteFieldStop(ctx); err != nil {
 25116  		return thrift.PrependError("write field stop error: ", err)
 25117  	}
 25118  	if err := tp.WriteStructEnd(ctx); err != nil {
 25119  		return thrift.PrependError("write struct stop error: ", err)
 25120  	}
 25121  	return nil
 25122  }
 25123  
 25124  func (p *ClusterInfoResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 25125  	if p.IsSetSuccess() {
 25126  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 25127  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 25128  		}
 25129  		if err := p.Success.Write(ctx, tp); err != nil {
 25130  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 25131  		}
 25132  		if err := tp.WriteFieldEnd(ctx); err != nil {
 25133  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 25134  		}
 25135  	}
 25136  	return err
 25137  }
 25138  
 25139  func (p *ClusterInfoResult) String() string {
 25140  	if p == nil {
 25141  		return "<nil>"
 25142  	}
 25143  	return fmt.Sprintf("ClusterInfoResult(%+v)", *p)
 25144  }
 25145  
 25146  // Attributes:
 25147  //  - Appid
 25148  //  - Sections
 25149  type InfoArgs struct {
 25150  	Appid    string   `thrift:"appid,1" db:"appid" json:"appid"`
 25151  	Sections []string `thrift:"sections,2" db:"sections" json:"sections"`
 25152  }
 25153  
 25154  func NewInfoArgs() *InfoArgs {
 25155  	return &InfoArgs{}
 25156  }
 25157  
 25158  func (p *InfoArgs) GetAppid() string {
 25159  	return p.Appid
 25160  }
 25161  
 25162  func (p *InfoArgs) GetSections() []string {
 25163  	return p.Sections
 25164  }
 25165  func (p *InfoArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 25166  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 25167  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 25168  	}
 25169  
 25170  	for {
 25171  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 25172  		if err != nil {
 25173  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 25174  		}
 25175  		if fieldTypeId == thrift.STOP {
 25176  			break
 25177  		}
 25178  		switch fieldId {
 25179  		case 1:
 25180  			if fieldTypeId == thrift.STRING {
 25181  				if err := p.ReadField1(ctx, tp); err != nil {
 25182  					return err
 25183  				}
 25184  			} else {
 25185  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25186  					return err
 25187  				}
 25188  			}
 25189  		case 2:
 25190  			if fieldTypeId == thrift.LIST {
 25191  				if err := p.ReadField2(ctx, tp); err != nil {
 25192  					return err
 25193  				}
 25194  			} else {
 25195  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25196  					return err
 25197  				}
 25198  			}
 25199  		default:
 25200  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25201  				return err
 25202  			}
 25203  		}
 25204  		if err := tp.ReadFieldEnd(ctx); err != nil {
 25205  			return err
 25206  		}
 25207  	}
 25208  	if err := tp.ReadStructEnd(ctx); err != nil {
 25209  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 25210  	}
 25211  	return nil
 25212  }
 25213  
 25214  func (p *InfoArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 25215  	if v, err := tp.ReadString(ctx); err != nil {
 25216  		return thrift.PrependError("error reading field 1: ", err)
 25217  	} else {
 25218  		p.Appid = v
 25219  	}
 25220  	return nil
 25221  }
 25222  
 25223  func (p *InfoArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 25224  	_, size, err := tp.ReadListBegin(ctx)
 25225  	if err != nil {
 25226  		return thrift.PrependError("error reading list begin: ", err)
 25227  	}
 25228  	tSlice := make([]string, 0, size)
 25229  	p.Sections = tSlice
 25230  	for i := 0; i < size; i++ {
 25231  		var _elem203 string
 25232  		if v, err := tp.ReadString(ctx); err != nil {
 25233  			return thrift.PrependError("error reading field 0: ", err)
 25234  		} else {
 25235  			_elem203 = v
 25236  		}
 25237  		p.Sections = append(p.Sections, _elem203)
 25238  	}
 25239  	if err := tp.ReadListEnd(ctx); err != nil {
 25240  		return thrift.PrependError("error reading list end: ", err)
 25241  	}
 25242  	return nil
 25243  }
 25244  
 25245  func (p *InfoArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 25246  	if err := tp.WriteStructBegin(ctx, "Info_args"); err != nil {
 25247  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25248  	}
 25249  	if p != nil {
 25250  		if err := p.writeField1(ctx, tp); err != nil {
 25251  			return err
 25252  		}
 25253  		if err := p.writeField2(ctx, tp); err != nil {
 25254  			return err
 25255  		}
 25256  	}
 25257  	if err := tp.WriteFieldStop(ctx); err != nil {
 25258  		return thrift.PrependError("write field stop error: ", err)
 25259  	}
 25260  	if err := tp.WriteStructEnd(ctx); err != nil {
 25261  		return thrift.PrependError("write struct stop error: ", err)
 25262  	}
 25263  	return nil
 25264  }
 25265  
 25266  func (p *InfoArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 25267  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 25268  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 25269  	}
 25270  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 25271  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 25272  	}
 25273  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25274  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 25275  	}
 25276  	return err
 25277  }
 25278  
 25279  func (p *InfoArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 25280  	if err := tp.WriteFieldBegin(ctx, "sections", thrift.LIST, 2); err != nil {
 25281  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:sections: ", p), err)
 25282  	}
 25283  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Sections)); err != nil {
 25284  		return thrift.PrependError("error writing list begin: ", err)
 25285  	}
 25286  	for _, v := range p.Sections {
 25287  		if err := tp.WriteString(ctx, string(v)); err != nil {
 25288  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 25289  		}
 25290  	}
 25291  	if err := tp.WriteListEnd(ctx); err != nil {
 25292  		return thrift.PrependError("error writing list end: ", err)
 25293  	}
 25294  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25295  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:sections: ", p), err)
 25296  	}
 25297  	return err
 25298  }
 25299  
 25300  func (p *InfoArgs) String() string {
 25301  	if p == nil {
 25302  		return "<nil>"
 25303  	}
 25304  	return fmt.Sprintf("InfoArgs(%+v)", *p)
 25305  }
 25306  
 25307  // Attributes:
 25308  //  - Success
 25309  type InfoResult struct {
 25310  	Success *MResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
 25311  }
 25312  
 25313  func NewInfoResult() *InfoResult {
 25314  	return &InfoResult{}
 25315  }
 25316  
 25317  var InfoResult_Success_DEFAULT *MResponse
 25318  
 25319  func (p *InfoResult) GetSuccess() *MResponse {
 25320  	if !p.IsSetSuccess() {
 25321  		return InfoResult_Success_DEFAULT
 25322  	}
 25323  	return p.Success
 25324  }
 25325  func (p *InfoResult) IsSetSuccess() bool {
 25326  	return p.Success != nil
 25327  }
 25328  
 25329  func (p *InfoResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 25330  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 25331  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 25332  	}
 25333  
 25334  	for {
 25335  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 25336  		if err != nil {
 25337  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 25338  		}
 25339  		if fieldTypeId == thrift.STOP {
 25340  			break
 25341  		}
 25342  		switch fieldId {
 25343  		case 0:
 25344  			if fieldTypeId == thrift.STRUCT {
 25345  				if err := p.ReadField0(ctx, tp); err != nil {
 25346  					return err
 25347  				}
 25348  			} else {
 25349  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25350  					return err
 25351  				}
 25352  			}
 25353  		default:
 25354  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25355  				return err
 25356  			}
 25357  		}
 25358  		if err := tp.ReadFieldEnd(ctx); err != nil {
 25359  			return err
 25360  		}
 25361  	}
 25362  	if err := tp.ReadStructEnd(ctx); err != nil {
 25363  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 25364  	}
 25365  	return nil
 25366  }
 25367  
 25368  func (p *InfoResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 25369  	p.Success = &MResponse{}
 25370  	if err := p.Success.Read(ctx, tp); err != nil {
 25371  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 25372  	}
 25373  	return nil
 25374  }
 25375  
 25376  func (p *InfoResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 25377  	if err := tp.WriteStructBegin(ctx, "Info_result"); err != nil {
 25378  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25379  	}
 25380  	if p != nil {
 25381  		if err := p.writeField0(ctx, tp); err != nil {
 25382  			return err
 25383  		}
 25384  	}
 25385  	if err := tp.WriteFieldStop(ctx); err != nil {
 25386  		return thrift.PrependError("write field stop error: ", err)
 25387  	}
 25388  	if err := tp.WriteStructEnd(ctx); err != nil {
 25389  		return thrift.PrependError("write struct stop error: ", err)
 25390  	}
 25391  	return nil
 25392  }
 25393  
 25394  func (p *InfoResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 25395  	if p.IsSetSuccess() {
 25396  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 25397  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 25398  		}
 25399  		if err := p.Success.Write(ctx, tp); err != nil {
 25400  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 25401  		}
 25402  		if err := tp.WriteFieldEnd(ctx); err != nil {
 25403  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 25404  		}
 25405  	}
 25406  	return err
 25407  }
 25408  
 25409  func (p *InfoResult) String() string {
 25410  	if p == nil {
 25411  		return "<nil>"
 25412  	}
 25413  	return fmt.Sprintf("InfoResult(%+v)", *p)
 25414  }
 25415  
 25416  // Attributes:
 25417  //  - Appid
 25418  //  - Addr
 25419  //  - Sections
 25420  type NodeInfoArgs struct {
 25421  	Appid    string   `thrift:"appid,1" db:"appid" json:"appid"`
 25422  	Addr     string   `thrift:"addr,2" db:"addr" json:"addr"`
 25423  	Sections []string `thrift:"sections,3" db:"sections" json:"sections"`
 25424  }
 25425  
 25426  func NewRedisProxyNodeInfoArgs() *NodeInfoArgs {
 25427  	return &NodeInfoArgs{}
 25428  }
 25429  
 25430  func (p *NodeInfoArgs) GetAppid() string {
 25431  	return p.Appid
 25432  }
 25433  
 25434  func (p *NodeInfoArgs) GetAddr() string {
 25435  	return p.Addr
 25436  }
 25437  
 25438  func (p *NodeInfoArgs) GetSections() []string {
 25439  	return p.Sections
 25440  }
 25441  func (p *NodeInfoArgs) Read(ctx context.Context, tp thrift.TProtocol) error {
 25442  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 25443  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 25444  	}
 25445  
 25446  	for {
 25447  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 25448  		if err != nil {
 25449  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 25450  		}
 25451  		if fieldTypeId == thrift.STOP {
 25452  			break
 25453  		}
 25454  		switch fieldId {
 25455  		case 1:
 25456  			if fieldTypeId == thrift.STRING {
 25457  				if err := p.ReadField1(ctx, tp); err != nil {
 25458  					return err
 25459  				}
 25460  			} else {
 25461  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25462  					return err
 25463  				}
 25464  			}
 25465  		case 2:
 25466  			if fieldTypeId == thrift.STRING {
 25467  				if err := p.ReadField2(ctx, tp); err != nil {
 25468  					return err
 25469  				}
 25470  			} else {
 25471  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25472  					return err
 25473  				}
 25474  			}
 25475  		case 3:
 25476  			if fieldTypeId == thrift.LIST {
 25477  				if err := p.ReadField3(ctx, tp); err != nil {
 25478  					return err
 25479  				}
 25480  			} else {
 25481  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25482  					return err
 25483  				}
 25484  			}
 25485  		default:
 25486  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25487  				return err
 25488  			}
 25489  		}
 25490  		if err := tp.ReadFieldEnd(ctx); err != nil {
 25491  			return err
 25492  		}
 25493  	}
 25494  	if err := tp.ReadStructEnd(ctx); err != nil {
 25495  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 25496  	}
 25497  	return nil
 25498  }
 25499  
 25500  func (p *NodeInfoArgs) ReadField1(ctx context.Context, tp thrift.TProtocol) error {
 25501  	if v, err := tp.ReadString(ctx); err != nil {
 25502  		return thrift.PrependError("error reading field 1: ", err)
 25503  	} else {
 25504  		p.Appid = v
 25505  	}
 25506  	return nil
 25507  }
 25508  
 25509  func (p *NodeInfoArgs) ReadField2(ctx context.Context, tp thrift.TProtocol) error {
 25510  	if v, err := tp.ReadString(ctx); err != nil {
 25511  		return thrift.PrependError("error reading field 2: ", err)
 25512  	} else {
 25513  		p.Addr = v
 25514  	}
 25515  	return nil
 25516  }
 25517  
 25518  func (p *NodeInfoArgs) ReadField3(ctx context.Context, tp thrift.TProtocol) error {
 25519  	_, size, err := tp.ReadListBegin(ctx)
 25520  	if err != nil {
 25521  		return thrift.PrependError("error reading list begin: ", err)
 25522  	}
 25523  	tSlice := make([]string, 0, size)
 25524  	p.Sections = tSlice
 25525  	for i := 0; i < size; i++ {
 25526  		var _elem204 string
 25527  		if v, err := tp.ReadString(ctx); err != nil {
 25528  			return thrift.PrependError("error reading field 0: ", err)
 25529  		} else {
 25530  			_elem204 = v
 25531  		}
 25532  		p.Sections = append(p.Sections, _elem204)
 25533  	}
 25534  	if err := tp.ReadListEnd(ctx); err != nil {
 25535  		return thrift.PrependError("error reading list end: ", err)
 25536  	}
 25537  	return nil
 25538  }
 25539  
 25540  func (p *NodeInfoArgs) Write(ctx context.Context, tp thrift.TProtocol) error {
 25541  	if err := tp.WriteStructBegin(ctx, "NodeInfo_args"); err != nil {
 25542  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25543  	}
 25544  	if p != nil {
 25545  		if err := p.writeField1(ctx, tp); err != nil {
 25546  			return err
 25547  		}
 25548  		if err := p.writeField2(ctx, tp); err != nil {
 25549  			return err
 25550  		}
 25551  		if err := p.writeField3(ctx, tp); err != nil {
 25552  			return err
 25553  		}
 25554  	}
 25555  	if err := tp.WriteFieldStop(ctx); err != nil {
 25556  		return thrift.PrependError("write field stop error: ", err)
 25557  	}
 25558  	if err := tp.WriteStructEnd(ctx); err != nil {
 25559  		return thrift.PrependError("write struct stop error: ", err)
 25560  	}
 25561  	return nil
 25562  }
 25563  
 25564  func (p *NodeInfoArgs) writeField1(ctx context.Context, tp thrift.TProtocol) (err error) {
 25565  	if err := tp.WriteFieldBegin(ctx, "appid", thrift.STRING, 1); err != nil {
 25566  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:appid: ", p), err)
 25567  	}
 25568  	if err := tp.WriteString(ctx, string(p.Appid)); err != nil {
 25569  		return thrift.PrependError(fmt.Sprintf("%T.appid (1) field write error: ", p), err)
 25570  	}
 25571  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25572  		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:appid: ", p), err)
 25573  	}
 25574  	return err
 25575  }
 25576  
 25577  func (p *NodeInfoArgs) writeField2(ctx context.Context, tp thrift.TProtocol) (err error) {
 25578  	if err := tp.WriteFieldBegin(ctx, "addr", thrift.STRING, 2); err != nil {
 25579  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:addr: ", p), err)
 25580  	}
 25581  	if err := tp.WriteString(ctx, string(p.Addr)); err != nil {
 25582  		return thrift.PrependError(fmt.Sprintf("%T.addr (2) field write error: ", p), err)
 25583  	}
 25584  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25585  		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:addr: ", p), err)
 25586  	}
 25587  	return err
 25588  }
 25589  
 25590  func (p *NodeInfoArgs) writeField3(ctx context.Context, tp thrift.TProtocol) (err error) {
 25591  	if err := tp.WriteFieldBegin(ctx, "sections", thrift.LIST, 3); err != nil {
 25592  		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:sections: ", p), err)
 25593  	}
 25594  	if err := tp.WriteListBegin(ctx, thrift.STRING, len(p.Sections)); err != nil {
 25595  		return thrift.PrependError("error writing list begin: ", err)
 25596  	}
 25597  	for _, v := range p.Sections {
 25598  		if err := tp.WriteString(ctx, string(v)); err != nil {
 25599  			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
 25600  		}
 25601  	}
 25602  	if err := tp.WriteListEnd(ctx); err != nil {
 25603  		return thrift.PrependError("error writing list end: ", err)
 25604  	}
 25605  	if err := tp.WriteFieldEnd(ctx); err != nil {
 25606  		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:sections: ", p), err)
 25607  	}
 25608  	return err
 25609  }
 25610  
 25611  func (p *NodeInfoArgs) String() string {
 25612  	if p == nil {
 25613  		return "<nil>"
 25614  	}
 25615  	return fmt.Sprintf("NodeInfoArgs(%+v)", *p)
 25616  }
 25617  
 25618  // Attributes:
 25619  //  - Success
 25620  type NodeInfoResult struct {
 25621  	Success *Response `thrift:"success,0" db:"success" json:"success,omitempty"`
 25622  }
 25623  
 25624  func NewNodeInfoResult() *NodeInfoResult {
 25625  	return &NodeInfoResult{}
 25626  }
 25627  
 25628  var NodeInfoResult_Success_DEFAULT *Response
 25629  
 25630  func (p *NodeInfoResult) GetSuccess() *Response {
 25631  	if !p.IsSetSuccess() {
 25632  		return NodeInfoResult_Success_DEFAULT
 25633  	}
 25634  	return p.Success
 25635  }
 25636  
 25637  func (p *NodeInfoResult) IsSetSuccess() bool {
 25638  	return p.Success != nil
 25639  }
 25640  
 25641  func (p *NodeInfoResult) Read(ctx context.Context, tp thrift.TProtocol) error {
 25642  	if _, err := tp.ReadStructBegin(ctx); err != nil {
 25643  		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
 25644  	}
 25645  
 25646  	for {
 25647  		_, fieldTypeId, fieldId, err := tp.ReadFieldBegin(ctx)
 25648  		if err != nil {
 25649  			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
 25650  		}
 25651  		if fieldTypeId == thrift.STOP {
 25652  			break
 25653  		}
 25654  		switch fieldId {
 25655  		case 0:
 25656  			if fieldTypeId == thrift.STRUCT {
 25657  				if err := p.ReadField0(ctx, tp); err != nil {
 25658  					return err
 25659  				}
 25660  			} else {
 25661  				if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25662  					return err
 25663  				}
 25664  			}
 25665  		default:
 25666  			if err := tp.Skip(ctx, fieldTypeId); err != nil {
 25667  				return err
 25668  			}
 25669  		}
 25670  		if err := tp.ReadFieldEnd(ctx); err != nil {
 25671  			return err
 25672  		}
 25673  	}
 25674  	if err := tp.ReadStructEnd(ctx); err != nil {
 25675  		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
 25676  	}
 25677  	return nil
 25678  }
 25679  
 25680  func (p *NodeInfoResult) ReadField0(ctx context.Context, tp thrift.TProtocol) error {
 25681  	p.Success = &Response{}
 25682  	if err := p.Success.Read(ctx, tp); err != nil {
 25683  		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
 25684  	}
 25685  	return nil
 25686  }
 25687  
 25688  func (p *NodeInfoResult) Write(ctx context.Context, tp thrift.TProtocol) error {
 25689  	if err := tp.WriteStructBegin(ctx, "NodeInfo_result"); err != nil {
 25690  		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
 25691  	}
 25692  	if p != nil {
 25693  		if err := p.writeField0(ctx, tp); err != nil {
 25694  			return err
 25695  		}
 25696  	}
 25697  	if err := tp.WriteFieldStop(ctx); err != nil {
 25698  		return thrift.PrependError("write field stop error: ", err)
 25699  	}
 25700  	if err := tp.WriteStructEnd(ctx); err != nil {
 25701  		return thrift.PrependError("write struct stop error: ", err)
 25702  	}
 25703  	return nil
 25704  }
 25705  
 25706  func (p *NodeInfoResult) writeField0(ctx context.Context, tp thrift.TProtocol) (err error) {
 25707  	if p.IsSetSuccess() {
 25708  		if err := tp.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
 25709  			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
 25710  		}
 25711  		if err := p.Success.Write(ctx, tp); err != nil {
 25712  			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
 25713  		}
 25714  		if err := tp.WriteFieldEnd(ctx); err != nil {
 25715  			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
 25716  		}
 25717  	}
 25718  	return err
 25719  }
 25720  
 25721  func (p *NodeInfoResult) String() string {
 25722  	if p == nil {
 25723  		return "<nil>"
 25724  	}
 25725  	return fmt.Sprintf("NodeInfoResult(%+v)", *p)
 25726  }