interaction.go

// Code generated by thriftgo (0.2.5). DO NOT EDIT.

package interaction

import (
	"context"
	"fmt"
	"github.com/CyanAsterisk/TikGok/server/shared/kitex_gen/base"
	"github.com/apache/thrift/lib/go/thrift"
	"strings"
)

type DouyinFavoriteActionRequest struct {
	UserId     int64 `thrift:"user_id,1" frugal:"1,default,i64" json:"user_id"`
	VideoId    int64 `thrift:"video_id,2" frugal:"2,default,i64" json:"video_id"`
	ActionType int8  `thrift:"action_type,3" frugal:"3,default,i8" json:"action_type"`
}

func NewDouyinFavoriteActionRequest() *DouyinFavoriteActionRequest {
	return &DouyinFavoriteActionRequest{}
}

func (p *DouyinFavoriteActionRequest) InitDefault() {
	*p = DouyinFavoriteActionRequest{}
}

func (p *DouyinFavoriteActionRequest) GetUserId() (v int64) {
	return p.UserId
}

func (p *DouyinFavoriteActionRequest) GetVideoId() (v int64) {
	return p.VideoId
}

func (p *DouyinFavoriteActionRequest) GetActionType() (v int8) {
	return p.ActionType
}
func (p *DouyinFavoriteActionRequest) SetUserId(val int64) {
	p.UserId = val
}
func (p *DouyinFavoriteActionRequest) SetVideoId(val int64) {
	p.VideoId = val
}
func (p *DouyinFavoriteActionRequest) SetActionType(val int8) {
	p.ActionType = val
}

var fieldIDToName_DouyinFavoriteActionRequest = map[int16]string{
	1: "user_id",
	2: "video_id",
	3: "action_type",
}

func (p *DouyinFavoriteActionRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.BYTE {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinFavoriteActionRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinFavoriteActionRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.UserId = v
	}
	return nil
}

func (p *DouyinFavoriteActionRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.VideoId = v
	}
	return nil
}

func (p *DouyinFavoriteActionRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return err
	} else {
		p.ActionType = v
	}
	return nil
}

func (p *DouyinFavoriteActionRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_favorite_action_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}
		if err = p.writeField3(oprot); err != nil {
			fieldId = 3
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinFavoriteActionRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("user_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.UserId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinFavoriteActionRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.VideoId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinFavoriteActionRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("action_type", thrift.BYTE, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteByte(p.ActionType); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

func (p *DouyinFavoriteActionRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinFavoriteActionRequest(%+v)", *p)
}

func (p *DouyinFavoriteActionRequest) DeepEqual(ano *DouyinFavoriteActionRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.UserId) {
		return false
	}
	if !p.Field2DeepEqual(ano.VideoId) {
		return false
	}
	if !p.Field3DeepEqual(ano.ActionType) {
		return false
	}
	return true
}

func (p *DouyinFavoriteActionRequest) Field1DeepEqual(src int64) bool {

	if p.UserId != src {
		return false
	}
	return true
}
func (p *DouyinFavoriteActionRequest) Field2DeepEqual(src int64) bool {

	if p.VideoId != src {
		return false
	}
	return true
}
func (p *DouyinFavoriteActionRequest) Field3DeepEqual(src int8) bool {

	if p.ActionType != src {
		return false
	}
	return true
}

type DouyinFavoriteActionResponse struct {
	BaseResp *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
}

func NewDouyinFavoriteActionResponse() *DouyinFavoriteActionResponse {
	return &DouyinFavoriteActionResponse{}
}

func (p *DouyinFavoriteActionResponse) InitDefault() {
	*p = DouyinFavoriteActionResponse{}
}

var DouyinFavoriteActionResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinFavoriteActionResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinFavoriteActionResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}
func (p *DouyinFavoriteActionResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}

var fieldIDToName_DouyinFavoriteActionResponse = map[int16]string{
	1: "base_resp",
}

func (p *DouyinFavoriteActionResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinFavoriteActionResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinFavoriteActionResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinFavoriteActionResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinFavoriteActionResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_favorite_action_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinFavoriteActionResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinFavoriteActionResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinFavoriteActionResponse(%+v)", *p)
}

func (p *DouyinFavoriteActionResponse) DeepEqual(ano *DouyinFavoriteActionResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	return true
}

func (p *DouyinFavoriteActionResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}

type DouyinGetFavoriteVideoIdListRequest struct {
	UserId int64 `thrift:"user_id,1" frugal:"1,default,i64" json:"user_id"`
}

func NewDouyinGetFavoriteVideoIdListRequest() *DouyinGetFavoriteVideoIdListRequest {
	return &DouyinGetFavoriteVideoIdListRequest{}
}

func (p *DouyinGetFavoriteVideoIdListRequest) InitDefault() {
	*p = DouyinGetFavoriteVideoIdListRequest{}
}

func (p *DouyinGetFavoriteVideoIdListRequest) GetUserId() (v int64) {
	return p.UserId
}
func (p *DouyinGetFavoriteVideoIdListRequest) SetUserId(val int64) {
	p.UserId = val
}

var fieldIDToName_DouyinGetFavoriteVideoIdListRequest = map[int16]string{
	1: "user_id",
}

func (p *DouyinGetFavoriteVideoIdListRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetFavoriteVideoIdListRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.UserId = v
	}
	return nil
}

func (p *DouyinGetFavoriteVideoIdListRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_favorite_video_id_list_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("user_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.UserId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetFavoriteVideoIdListRequest(%+v)", *p)
}

func (p *DouyinGetFavoriteVideoIdListRequest) DeepEqual(ano *DouyinGetFavoriteVideoIdListRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.UserId) {
		return false
	}
	return true
}

func (p *DouyinGetFavoriteVideoIdListRequest) Field1DeepEqual(src int64) bool {

	if p.UserId != src {
		return false
	}
	return true
}

type DouyinGetFavoriteVideoIdListResponse struct {
	BaseResp    *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	VideoIdList []int64                  `thrift:"video_id_list,2" frugal:"2,default,list<i64>" json:"video_id_list"`
}

func NewDouyinGetFavoriteVideoIdListResponse() *DouyinGetFavoriteVideoIdListResponse {
	return &DouyinGetFavoriteVideoIdListResponse{}
}

func (p *DouyinGetFavoriteVideoIdListResponse) InitDefault() {
	*p = DouyinGetFavoriteVideoIdListResponse{}
}

var DouyinGetFavoriteVideoIdListResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinGetFavoriteVideoIdListResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinGetFavoriteVideoIdListResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

func (p *DouyinGetFavoriteVideoIdListResponse) GetVideoIdList() (v []int64) {
	return p.VideoIdList
}
func (p *DouyinGetFavoriteVideoIdListResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinGetFavoriteVideoIdListResponse) SetVideoIdList(val []int64) {
	p.VideoIdList = val
}

var fieldIDToName_DouyinGetFavoriteVideoIdListResponse = map[int16]string{
	1: "base_resp",
	2: "video_id_list",
}

func (p *DouyinGetFavoriteVideoIdListResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinGetFavoriteVideoIdListResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetFavoriteVideoIdListResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetFavoriteVideoIdListResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.VideoIdList = make([]int64, 0, size)
	for i := 0; i < size; i++ {
		var _elem int64
		if v, err := iprot.ReadI64(); err != nil {
			return err
		} else {
			_elem = v
		}

		p.VideoIdList = append(p.VideoIdList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetFavoriteVideoIdListResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_favorite_video_id_list_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id_list", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.I64, len(p.VideoIdList)); err != nil {
		return err
	}
	for _, v := range p.VideoIdList {
		if err := oprot.WriteI64(v); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinGetFavoriteVideoIdListResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetFavoriteVideoIdListResponse(%+v)", *p)
}

func (p *DouyinGetFavoriteVideoIdListResponse) DeepEqual(ano *DouyinGetFavoriteVideoIdListResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.VideoIdList) {
		return false
	}
	return true
}

func (p *DouyinGetFavoriteVideoIdListResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinGetFavoriteVideoIdListResponse) Field2DeepEqual(src []int64) bool {

	if len(p.VideoIdList) != len(src) {
		return false
	}
	for i, v := range p.VideoIdList {
		_src := src[i]
		if v != _src {
			return false
		}
	}
	return true
}

type DouyinCommentActionRequest struct {
	UserId      int64  `thrift:"user_id,1" frugal:"1,default,i64" json:"user_id"`
	VideoId     int64  `thrift:"video_id,2" frugal:"2,default,i64" json:"video_id"`
	ActionType  int8   `thrift:"action_type,3" frugal:"3,default,i8" json:"action_type"`
	CommentText string `thrift:"comment_text,4" frugal:"4,default,string" json:"comment_text"`
	CommentId   int64  `thrift:"comment_id,5" frugal:"5,default,i64" json:"comment_id"`
}

func NewDouyinCommentActionRequest() *DouyinCommentActionRequest {
	return &DouyinCommentActionRequest{}
}

func (p *DouyinCommentActionRequest) InitDefault() {
	*p = DouyinCommentActionRequest{}
}

func (p *DouyinCommentActionRequest) GetUserId() (v int64) {
	return p.UserId
}

func (p *DouyinCommentActionRequest) GetVideoId() (v int64) {
	return p.VideoId
}

func (p *DouyinCommentActionRequest) GetActionType() (v int8) {
	return p.ActionType
}

func (p *DouyinCommentActionRequest) GetCommentText() (v string) {
	return p.CommentText
}

func (p *DouyinCommentActionRequest) GetCommentId() (v int64) {
	return p.CommentId
}
func (p *DouyinCommentActionRequest) SetUserId(val int64) {
	p.UserId = val
}
func (p *DouyinCommentActionRequest) SetVideoId(val int64) {
	p.VideoId = val
}
func (p *DouyinCommentActionRequest) SetActionType(val int8) {
	p.ActionType = val
}
func (p *DouyinCommentActionRequest) SetCommentText(val string) {
	p.CommentText = val
}
func (p *DouyinCommentActionRequest) SetCommentId(val int64) {
	p.CommentId = val
}

var fieldIDToName_DouyinCommentActionRequest = map[int16]string{
	1: "user_id",
	2: "video_id",
	3: "action_type",
	4: "comment_text",
	5: "comment_id",
}

func (p *DouyinCommentActionRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.BYTE {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinCommentActionRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinCommentActionRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.UserId = v
	}
	return nil
}

func (p *DouyinCommentActionRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.VideoId = v
	}
	return nil
}

func (p *DouyinCommentActionRequest) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return err
	} else {
		p.ActionType = v
	}
	return nil
}

func (p *DouyinCommentActionRequest) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.CommentText = v
	}
	return nil
}

func (p *DouyinCommentActionRequest) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.CommentId = v
	}
	return nil
}

func (p *DouyinCommentActionRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_comment_action_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}
		if err = p.writeField3(oprot); err != nil {
			fieldId = 3
			goto WriteFieldError
		}
		if err = p.writeField4(oprot); err != nil {
			fieldId = 4
			goto WriteFieldError
		}
		if err = p.writeField5(oprot); err != nil {
			fieldId = 5
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinCommentActionRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("user_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.UserId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinCommentActionRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.VideoId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinCommentActionRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("action_type", thrift.BYTE, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteByte(p.ActionType); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

func (p *DouyinCommentActionRequest) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("comment_text", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.CommentText); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err)
}

func (p *DouyinCommentActionRequest) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("comment_id", thrift.I64, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.CommentId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err)
}

func (p *DouyinCommentActionRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinCommentActionRequest(%+v)", *p)
}

func (p *DouyinCommentActionRequest) DeepEqual(ano *DouyinCommentActionRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.UserId) {
		return false
	}
	if !p.Field2DeepEqual(ano.VideoId) {
		return false
	}
	if !p.Field3DeepEqual(ano.ActionType) {
		return false
	}
	if !p.Field4DeepEqual(ano.CommentText) {
		return false
	}
	if !p.Field5DeepEqual(ano.CommentId) {
		return false
	}
	return true
}

func (p *DouyinCommentActionRequest) Field1DeepEqual(src int64) bool {

	if p.UserId != src {
		return false
	}
	return true
}
func (p *DouyinCommentActionRequest) Field2DeepEqual(src int64) bool {

	if p.VideoId != src {
		return false
	}
	return true
}
func (p *DouyinCommentActionRequest) Field3DeepEqual(src int8) bool {

	if p.ActionType != src {
		return false
	}
	return true
}
func (p *DouyinCommentActionRequest) Field4DeepEqual(src string) bool {

	if strings.Compare(p.CommentText, src) != 0 {
		return false
	}
	return true
}
func (p *DouyinCommentActionRequest) Field5DeepEqual(src int64) bool {

	if p.CommentId != src {
		return false
	}
	return true
}

type DouyinCommentActionResponse struct {
	BaseResp *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	Comment  *base.Comment            `thrift:"comment,2" frugal:"2,default,base.Comment" json:"comment"`
}

func NewDouyinCommentActionResponse() *DouyinCommentActionResponse {
	return &DouyinCommentActionResponse{}
}

func (p *DouyinCommentActionResponse) InitDefault() {
	*p = DouyinCommentActionResponse{}
}

var DouyinCommentActionResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinCommentActionResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinCommentActionResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

var DouyinCommentActionResponse_Comment_DEFAULT *base.Comment

func (p *DouyinCommentActionResponse) GetComment() (v *base.Comment) {
	if !p.IsSetComment() {
		return DouyinCommentActionResponse_Comment_DEFAULT
	}
	return p.Comment
}
func (p *DouyinCommentActionResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinCommentActionResponse) SetComment(val *base.Comment) {
	p.Comment = val
}

var fieldIDToName_DouyinCommentActionResponse = map[int16]string{
	1: "base_resp",
	2: "comment",
}

func (p *DouyinCommentActionResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinCommentActionResponse) IsSetComment() bool {
	return p.Comment != nil
}

func (p *DouyinCommentActionResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinCommentActionResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinCommentActionResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinCommentActionResponse) ReadField2(iprot thrift.TProtocol) error {
	p.Comment = base.NewComment()
	if err := p.Comment.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinCommentActionResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_comment_action_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinCommentActionResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinCommentActionResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("comment", thrift.STRUCT, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Comment.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinCommentActionResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinCommentActionResponse(%+v)", *p)
}

func (p *DouyinCommentActionResponse) DeepEqual(ano *DouyinCommentActionResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.Comment) {
		return false
	}
	return true
}

func (p *DouyinCommentActionResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinCommentActionResponse) Field2DeepEqual(src *base.Comment) bool {

	if !p.Comment.DeepEqual(src) {
		return false
	}
	return true
}

type DouyinGetCommentListRequest struct {
	VideoId int64 `thrift:"video_id,1" frugal:"1,default,i64" json:"video_id"`
}

func NewDouyinGetCommentListRequest() *DouyinGetCommentListRequest {
	return &DouyinGetCommentListRequest{}
}

func (p *DouyinGetCommentListRequest) InitDefault() {
	*p = DouyinGetCommentListRequest{}
}

func (p *DouyinGetCommentListRequest) GetVideoId() (v int64) {
	return p.VideoId
}
func (p *DouyinGetCommentListRequest) SetVideoId(val int64) {
	p.VideoId = val
}

var fieldIDToName_DouyinGetCommentListRequest = map[int16]string{
	1: "video_id",
}

func (p *DouyinGetCommentListRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetCommentListRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetCommentListRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.VideoId = v
	}
	return nil
}

func (p *DouyinGetCommentListRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_comment_list_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetCommentListRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.VideoId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetCommentListRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetCommentListRequest(%+v)", *p)
}

func (p *DouyinGetCommentListRequest) DeepEqual(ano *DouyinGetCommentListRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.VideoId) {
		return false
	}
	return true
}

func (p *DouyinGetCommentListRequest) Field1DeepEqual(src int64) bool {

	if p.VideoId != src {
		return false
	}
	return true
}

type DouyinGetCommentListResponse struct {
	BaseResp    *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	CommentList []*base.Comment          `thrift:"comment_list,2" frugal:"2,default,list<base.Comment>" json:"comment_list"`
}

func NewDouyinGetCommentListResponse() *DouyinGetCommentListResponse {
	return &DouyinGetCommentListResponse{}
}

func (p *DouyinGetCommentListResponse) InitDefault() {
	*p = DouyinGetCommentListResponse{}
}

var DouyinGetCommentListResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinGetCommentListResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinGetCommentListResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

func (p *DouyinGetCommentListResponse) GetCommentList() (v []*base.Comment) {
	return p.CommentList
}
func (p *DouyinGetCommentListResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinGetCommentListResponse) SetCommentList(val []*base.Comment) {
	p.CommentList = val
}

var fieldIDToName_DouyinGetCommentListResponse = map[int16]string{
	1: "base_resp",
	2: "comment_list",
}

func (p *DouyinGetCommentListResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinGetCommentListResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetCommentListResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetCommentListResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetCommentListResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.CommentList = make([]*base.Comment, 0, size)
	for i := 0; i < size; i++ {
		_elem := base.NewComment()
		if err := _elem.Read(iprot); err != nil {
			return err
		}

		p.CommentList = append(p.CommentList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetCommentListResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_comment_list_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetCommentListResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetCommentListResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("comment_list", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.CommentList)); err != nil {
		return err
	}
	for _, v := range p.CommentList {
		if err := v.Write(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinGetCommentListResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetCommentListResponse(%+v)", *p)
}

func (p *DouyinGetCommentListResponse) DeepEqual(ano *DouyinGetCommentListResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.CommentList) {
		return false
	}
	return true
}

func (p *DouyinGetCommentListResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinGetCommentListResponse) Field2DeepEqual(src []*base.Comment) bool {

	if len(p.CommentList) != len(src) {
		return false
	}
	for i, v := range p.CommentList {
		_src := src[i]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}

type DouyinGetVideoInteractInfoRequest struct {
	VideoId  int64 `thrift:"video_id,1" frugal:"1,default,i64" json:"video_id"`
	ViewerId int64 `thrift:"viewer_id,2" frugal:"2,default,i64" json:"viewer_id"`
}

func NewDouyinGetVideoInteractInfoRequest() *DouyinGetVideoInteractInfoRequest {
	return &DouyinGetVideoInteractInfoRequest{}
}

func (p *DouyinGetVideoInteractInfoRequest) InitDefault() {
	*p = DouyinGetVideoInteractInfoRequest{}
}

func (p *DouyinGetVideoInteractInfoRequest) GetVideoId() (v int64) {
	return p.VideoId
}

func (p *DouyinGetVideoInteractInfoRequest) GetViewerId() (v int64) {
	return p.ViewerId
}
func (p *DouyinGetVideoInteractInfoRequest) SetVideoId(val int64) {
	p.VideoId = val
}
func (p *DouyinGetVideoInteractInfoRequest) SetViewerId(val int64) {
	p.ViewerId = val
}

var fieldIDToName_DouyinGetVideoInteractInfoRequest = map[int16]string{
	1: "video_id",
	2: "viewer_id",
}

func (p *DouyinGetVideoInteractInfoRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetVideoInteractInfoRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.VideoId = v
	}
	return nil
}

func (p *DouyinGetVideoInteractInfoRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.ViewerId = v
	}
	return nil
}

func (p *DouyinGetVideoInteractInfoRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_video_interact_info_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.VideoId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("viewer_id", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.ViewerId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetVideoInteractInfoRequest(%+v)", *p)
}

func (p *DouyinGetVideoInteractInfoRequest) DeepEqual(ano *DouyinGetVideoInteractInfoRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.VideoId) {
		return false
	}
	if !p.Field2DeepEqual(ano.ViewerId) {
		return false
	}
	return true
}

func (p *DouyinGetVideoInteractInfoRequest) Field1DeepEqual(src int64) bool {

	if p.VideoId != src {
		return false
	}
	return true
}
func (p *DouyinGetVideoInteractInfoRequest) Field2DeepEqual(src int64) bool {

	if p.ViewerId != src {
		return false
	}
	return true
}

type DouyinGetVideoInteractInfoResponse struct {
	BaseResp     *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	InteractInfo *base.VideoInteractInfo  `thrift:"interact_info,2" frugal:"2,default,base.VideoInteractInfo" json:"interact_info"`
}

func NewDouyinGetVideoInteractInfoResponse() *DouyinGetVideoInteractInfoResponse {
	return &DouyinGetVideoInteractInfoResponse{}
}

func (p *DouyinGetVideoInteractInfoResponse) InitDefault() {
	*p = DouyinGetVideoInteractInfoResponse{}
}

var DouyinGetVideoInteractInfoResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinGetVideoInteractInfoResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinGetVideoInteractInfoResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

var DouyinGetVideoInteractInfoResponse_InteractInfo_DEFAULT *base.VideoInteractInfo

func (p *DouyinGetVideoInteractInfoResponse) GetInteractInfo() (v *base.VideoInteractInfo) {
	if !p.IsSetInteractInfo() {
		return DouyinGetVideoInteractInfoResponse_InteractInfo_DEFAULT
	}
	return p.InteractInfo
}
func (p *DouyinGetVideoInteractInfoResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinGetVideoInteractInfoResponse) SetInteractInfo(val *base.VideoInteractInfo) {
	p.InteractInfo = val
}

var fieldIDToName_DouyinGetVideoInteractInfoResponse = map[int16]string{
	1: "base_resp",
	2: "interact_info",
}

func (p *DouyinGetVideoInteractInfoResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinGetVideoInteractInfoResponse) IsSetInteractInfo() bool {
	return p.InteractInfo != nil
}

func (p *DouyinGetVideoInteractInfoResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetVideoInteractInfoResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetVideoInteractInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	p.InteractInfo = base.NewVideoInteractInfo()
	if err := p.InteractInfo.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetVideoInteractInfoResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_video_interact_info_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("interact_info", thrift.STRUCT, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InteractInfo.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinGetVideoInteractInfoResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetVideoInteractInfoResponse(%+v)", *p)
}

func (p *DouyinGetVideoInteractInfoResponse) DeepEqual(ano *DouyinGetVideoInteractInfoResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.InteractInfo) {
		return false
	}
	return true
}

func (p *DouyinGetVideoInteractInfoResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinGetVideoInteractInfoResponse) Field2DeepEqual(src *base.VideoInteractInfo) bool {

	if !p.InteractInfo.DeepEqual(src) {
		return false
	}
	return true
}

type DouyinBatchGetVideoInteractInfoRequest struct {
	VideoIdList []int64 `thrift:"video_id_list,1" frugal:"1,default,list<i64>" json:"video_id_list"`
	ViewerId    int64   `thrift:"viewer_id,2" frugal:"2,default,i64" json:"viewer_id"`
}

func NewDouyinBatchGetVideoInteractInfoRequest() *DouyinBatchGetVideoInteractInfoRequest {
	return &DouyinBatchGetVideoInteractInfoRequest{}
}

func (p *DouyinBatchGetVideoInteractInfoRequest) InitDefault() {
	*p = DouyinBatchGetVideoInteractInfoRequest{}
}

func (p *DouyinBatchGetVideoInteractInfoRequest) GetVideoIdList() (v []int64) {
	return p.VideoIdList
}

func (p *DouyinBatchGetVideoInteractInfoRequest) GetViewerId() (v int64) {
	return p.ViewerId
}
func (p *DouyinBatchGetVideoInteractInfoRequest) SetVideoIdList(val []int64) {
	p.VideoIdList = val
}
func (p *DouyinBatchGetVideoInteractInfoRequest) SetViewerId(val int64) {
	p.ViewerId = val
}

var fieldIDToName_DouyinBatchGetVideoInteractInfoRequest = map[int16]string{
	1: "video_id_list",
	2: "viewer_id",
}

func (p *DouyinBatchGetVideoInteractInfoRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinBatchGetVideoInteractInfoRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoRequest) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.VideoIdList = make([]int64, 0, size)
	for i := 0; i < size; i++ {
		var _elem int64
		if v, err := iprot.ReadI64(); err != nil {
			return err
		} else {
			_elem = v
		}

		p.VideoIdList = append(p.VideoIdList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetVideoInteractInfoRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.ViewerId = v
	}
	return nil
}

func (p *DouyinBatchGetVideoInteractInfoRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_batch_get_video_interact_info_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("video_id_list", thrift.LIST, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.I64, len(p.VideoIdList)); err != nil {
		return err
	}
	for _, v := range p.VideoIdList {
		if err := oprot.WriteI64(v); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("viewer_id", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.ViewerId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinBatchGetVideoInteractInfoRequest(%+v)", *p)
}

func (p *DouyinBatchGetVideoInteractInfoRequest) DeepEqual(ano *DouyinBatchGetVideoInteractInfoRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.VideoIdList) {
		return false
	}
	if !p.Field2DeepEqual(ano.ViewerId) {
		return false
	}
	return true
}

func (p *DouyinBatchGetVideoInteractInfoRequest) Field1DeepEqual(src []int64) bool {

	if len(p.VideoIdList) != len(src) {
		return false
	}
	for i, v := range p.VideoIdList {
		_src := src[i]
		if v != _src {
			return false
		}
	}
	return true
}
func (p *DouyinBatchGetVideoInteractInfoRequest) Field2DeepEqual(src int64) bool {

	if p.ViewerId != src {
		return false
	}
	return true
}

type DouyinBatchGetVideoInteractInfoResponse struct {
	BaseResp         *base.DouyinBaseResponse  `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	InteractInfoList []*base.VideoInteractInfo `thrift:"interact_info_list,2" frugal:"2,default,list<base.VideoInteractInfo>" json:"interact_info_list"`
}

func NewDouyinBatchGetVideoInteractInfoResponse() *DouyinBatchGetVideoInteractInfoResponse {
	return &DouyinBatchGetVideoInteractInfoResponse{}
}

func (p *DouyinBatchGetVideoInteractInfoResponse) InitDefault() {
	*p = DouyinBatchGetVideoInteractInfoResponse{}
}

var DouyinBatchGetVideoInteractInfoResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinBatchGetVideoInteractInfoResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinBatchGetVideoInteractInfoResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

func (p *DouyinBatchGetVideoInteractInfoResponse) GetInteractInfoList() (v []*base.VideoInteractInfo) {
	return p.InteractInfoList
}
func (p *DouyinBatchGetVideoInteractInfoResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinBatchGetVideoInteractInfoResponse) SetInteractInfoList(val []*base.VideoInteractInfo) {
	p.InteractInfoList = val
}

var fieldIDToName_DouyinBatchGetVideoInteractInfoResponse = map[int16]string{
	1: "base_resp",
	2: "interact_info_list",
}

func (p *DouyinBatchGetVideoInteractInfoResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinBatchGetVideoInteractInfoResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinBatchGetVideoInteractInfoResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetVideoInteractInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.InteractInfoList = make([]*base.VideoInteractInfo, 0, size)
	for i := 0; i < size; i++ {
		_elem := base.NewVideoInteractInfo()
		if err := _elem.Read(iprot); err != nil {
			return err
		}

		p.InteractInfoList = append(p.InteractInfoList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetVideoInteractInfoResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_batch_get_video_interact_info_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("interact_info_list", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.InteractInfoList)); err != nil {
		return err
	}
	for _, v := range p.InteractInfoList {
		if err := v.Write(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinBatchGetVideoInteractInfoResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinBatchGetVideoInteractInfoResponse(%+v)", *p)
}

func (p *DouyinBatchGetVideoInteractInfoResponse) DeepEqual(ano *DouyinBatchGetVideoInteractInfoResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.InteractInfoList) {
		return false
	}
	return true
}

func (p *DouyinBatchGetVideoInteractInfoResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinBatchGetVideoInteractInfoResponse) Field2DeepEqual(src []*base.VideoInteractInfo) bool {

	if len(p.InteractInfoList) != len(src) {
		return false
	}
	for i, v := range p.InteractInfoList {
		_src := src[i]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}

type DouyinGetUserInteractInfoRequest struct {
	UserId int64 `thrift:"user_id,1" frugal:"1,default,i64" json:"user_id"`
}

func NewDouyinGetUserInteractInfoRequest() *DouyinGetUserInteractInfoRequest {
	return &DouyinGetUserInteractInfoRequest{}
}

func (p *DouyinGetUserInteractInfoRequest) InitDefault() {
	*p = DouyinGetUserInteractInfoRequest{}
}

func (p *DouyinGetUserInteractInfoRequest) GetUserId() (v int64) {
	return p.UserId
}
func (p *DouyinGetUserInteractInfoRequest) SetUserId(val int64) {
	p.UserId = val
}

var fieldIDToName_DouyinGetUserInteractInfoRequest = map[int16]string{
	1: "user_id",
}

func (p *DouyinGetUserInteractInfoRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetUserInteractInfoRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoRequest) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.UserId = v
	}
	return nil
}

func (p *DouyinGetUserInteractInfoRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_user_interact_info_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("user_id", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.UserId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetUserInteractInfoRequest(%+v)", *p)
}

func (p *DouyinGetUserInteractInfoRequest) DeepEqual(ano *DouyinGetUserInteractInfoRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.UserId) {
		return false
	}
	return true
}

func (p *DouyinGetUserInteractInfoRequest) Field1DeepEqual(src int64) bool {

	if p.UserId != src {
		return false
	}
	return true
}

type DouyinGetUserInteractInfoResponse struct {
	BaseResp     *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	InteractInfo *base.UserInteractInfo   `thrift:"interact_info,2" frugal:"2,default,base.UserInteractInfo" json:"interact_info"`
}

func NewDouyinGetUserInteractInfoResponse() *DouyinGetUserInteractInfoResponse {
	return &DouyinGetUserInteractInfoResponse{}
}

func (p *DouyinGetUserInteractInfoResponse) InitDefault() {
	*p = DouyinGetUserInteractInfoResponse{}
}

var DouyinGetUserInteractInfoResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinGetUserInteractInfoResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinGetUserInteractInfoResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

var DouyinGetUserInteractInfoResponse_InteractInfo_DEFAULT *base.UserInteractInfo

func (p *DouyinGetUserInteractInfoResponse) GetInteractInfo() (v *base.UserInteractInfo) {
	if !p.IsSetInteractInfo() {
		return DouyinGetUserInteractInfoResponse_InteractInfo_DEFAULT
	}
	return p.InteractInfo
}
func (p *DouyinGetUserInteractInfoResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinGetUserInteractInfoResponse) SetInteractInfo(val *base.UserInteractInfo) {
	p.InteractInfo = val
}

var fieldIDToName_DouyinGetUserInteractInfoResponse = map[int16]string{
	1: "base_resp",
	2: "interact_info",
}

func (p *DouyinGetUserInteractInfoResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinGetUserInteractInfoResponse) IsSetInteractInfo() bool {
	return p.InteractInfo != nil
}

func (p *DouyinGetUserInteractInfoResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinGetUserInteractInfoResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetUserInteractInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	p.InteractInfo = base.NewUserInteractInfo()
	if err := p.InteractInfo.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinGetUserInteractInfoResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_get_user_interact_info_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("interact_info", thrift.STRUCT, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InteractInfo.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinGetUserInteractInfoResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinGetUserInteractInfoResponse(%+v)", *p)
}

func (p *DouyinGetUserInteractInfoResponse) DeepEqual(ano *DouyinGetUserInteractInfoResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.InteractInfo) {
		return false
	}
	return true
}

func (p *DouyinGetUserInteractInfoResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinGetUserInteractInfoResponse) Field2DeepEqual(src *base.UserInteractInfo) bool {

	if !p.InteractInfo.DeepEqual(src) {
		return false
	}
	return true
}

type DouyinBatchGetUserInteractInfoRequest struct {
	UserIdList []int64 `thrift:"user_id_list,1" frugal:"1,default,list<i64>" json:"user_id_list"`
}

func NewDouyinBatchGetUserInteractInfoRequest() *DouyinBatchGetUserInteractInfoRequest {
	return &DouyinBatchGetUserInteractInfoRequest{}
}

func (p *DouyinBatchGetUserInteractInfoRequest) InitDefault() {
	*p = DouyinBatchGetUserInteractInfoRequest{}
}

func (p *DouyinBatchGetUserInteractInfoRequest) GetUserIdList() (v []int64) {
	return p.UserIdList
}
func (p *DouyinBatchGetUserInteractInfoRequest) SetUserIdList(val []int64) {
	p.UserIdList = val
}

var fieldIDToName_DouyinBatchGetUserInteractInfoRequest = map[int16]string{
	1: "user_id_list",
}

func (p *DouyinBatchGetUserInteractInfoRequest) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinBatchGetUserInteractInfoRequest[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoRequest) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.UserIdList = make([]int64, 0, size)
	for i := 0; i < size; i++ {
		var _elem int64
		if v, err := iprot.ReadI64(); err != nil {
			return err
		} else {
			_elem = v
		}

		p.UserIdList = append(p.UserIdList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetUserInteractInfoRequest) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_batch_get_user_interact_info_request"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("user_id_list", thrift.LIST, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.I64, len(p.UserIdList)); err != nil {
		return err
	}
	for _, v := range p.UserIdList {
		if err := oprot.WriteI64(v); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinBatchGetUserInteractInfoRequest(%+v)", *p)
}

func (p *DouyinBatchGetUserInteractInfoRequest) DeepEqual(ano *DouyinBatchGetUserInteractInfoRequest) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.UserIdList) {
		return false
	}
	return true
}

func (p *DouyinBatchGetUserInteractInfoRequest) Field1DeepEqual(src []int64) bool {

	if len(p.UserIdList) != len(src) {
		return false
	}
	for i, v := range p.UserIdList {
		_src := src[i]
		if v != _src {
			return false
		}
	}
	return true
}

type DouyinBatchGetUserInteractInfoResponse struct {
	BaseResp         *base.DouyinBaseResponse `thrift:"base_resp,1" frugal:"1,default,base.DouyinBaseResponse" json:"base_resp"`
	InteractInfoList []*base.UserInteractInfo `thrift:"interact_info_list,2" frugal:"2,default,list<base.UserInteractInfo>" json:"interact_info_list"`
}

func NewDouyinBatchGetUserInteractInfoResponse() *DouyinBatchGetUserInteractInfoResponse {
	return &DouyinBatchGetUserInteractInfoResponse{}
}

func (p *DouyinBatchGetUserInteractInfoResponse) InitDefault() {
	*p = DouyinBatchGetUserInteractInfoResponse{}
}

var DouyinBatchGetUserInteractInfoResponse_BaseResp_DEFAULT *base.DouyinBaseResponse

func (p *DouyinBatchGetUserInteractInfoResponse) GetBaseResp() (v *base.DouyinBaseResponse) {
	if !p.IsSetBaseResp() {
		return DouyinBatchGetUserInteractInfoResponse_BaseResp_DEFAULT
	}
	return p.BaseResp
}

func (p *DouyinBatchGetUserInteractInfoResponse) GetInteractInfoList() (v []*base.UserInteractInfo) {
	return p.InteractInfoList
}
func (p *DouyinBatchGetUserInteractInfoResponse) SetBaseResp(val *base.DouyinBaseResponse) {
	p.BaseResp = val
}
func (p *DouyinBatchGetUserInteractInfoResponse) SetInteractInfoList(val []*base.UserInteractInfo) {
	p.InteractInfoList = val
}

var fieldIDToName_DouyinBatchGetUserInteractInfoResponse = map[int16]string{
	1: "base_resp",
	2: "interact_info_list",
}

func (p *DouyinBatchGetUserInteractInfoResponse) IsSetBaseResp() bool {
	return p.BaseResp != nil
}

func (p *DouyinBatchGetUserInteractInfoResponse) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_DouyinBatchGetUserInteractInfoResponse[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoResponse) ReadField1(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewDouyinBaseResponse()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetUserInteractInfoResponse) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.InteractInfoList = make([]*base.UserInteractInfo, 0, size)
	for i := 0; i < size; i++ {
		_elem := base.NewUserInteractInfo()
		if err := _elem.Read(iprot); err != nil {
			return err
		}

		p.InteractInfoList = append(p.InteractInfoList, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *DouyinBatchGetUserInteractInfoResponse) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("douyin_batch_get_user_interact_info_response"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("base_resp", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.BaseResp.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("interact_info_list", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.InteractInfoList)); err != nil {
		return err
	}
	for _, v := range p.InteractInfoList {
		if err := v.Write(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *DouyinBatchGetUserInteractInfoResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DouyinBatchGetUserInteractInfoResponse(%+v)", *p)
}

func (p *DouyinBatchGetUserInteractInfoResponse) DeepEqual(ano *DouyinBatchGetUserInteractInfoResponse) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.BaseResp) {
		return false
	}
	if !p.Field2DeepEqual(ano.InteractInfoList) {
		return false
	}
	return true
}

func (p *DouyinBatchGetUserInteractInfoResponse) Field1DeepEqual(src *base.DouyinBaseResponse) bool {

	if !p.BaseResp.DeepEqual(src) {
		return false
	}
	return true
}
func (p *DouyinBatchGetUserInteractInfoResponse) Field2DeepEqual(src []*base.UserInteractInfo) bool {

	if len(p.InteractInfoList) != len(src) {
		return false
	}
	for i, v := range p.InteractInfoList {
		_src := src[i]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}

type InteractionServer interface {
	Favorite(ctx context.Context, req *DouyinFavoriteActionRequest) (r *DouyinFavoriteActionResponse, err error)

	GetFavoriteVideoIdList(ctx context.Context, req *DouyinGetFavoriteVideoIdListRequest) (r *DouyinGetFavoriteVideoIdListResponse, err error)

	Comment(ctx context.Context, req *DouyinCommentActionRequest) (r *DouyinCommentActionResponse, err error)

	GetCommentList(ctx context.Context, req *DouyinGetCommentListRequest) (r *DouyinGetCommentListResponse, err error)

	GetVideoInteractInfo(ctx context.Context, req *DouyinGetVideoInteractInfoRequest) (r *DouyinGetVideoInteractInfoResponse, err error)

	BatchGetVideoInteractInfo(ctx context.Context, req *DouyinBatchGetVideoInteractInfoRequest) (r *DouyinBatchGetVideoInteractInfoResponse, err error)

	GetUserInteractInfo(ctx context.Context, req *DouyinGetUserInteractInfoRequest) (r *DouyinGetUserInteractInfoResponse, err error)

	BatchGetUserInteractInfo(ctx context.Context, req *DouyinBatchGetUserInteractInfoRequest) (r *DouyinBatchGetUserInteractInfoResponse, err error)
}

type InteractionServerClient struct {
	c thrift.TClient
}

func NewInteractionServerClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *InteractionServerClient {
	return &InteractionServerClient{
		c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)),
	}
}

func NewInteractionServerClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *InteractionServerClient {
	return &InteractionServerClient{
		c: thrift.NewTStandardClient(iprot, oprot),
	}
}

func NewInteractionServerClient(c thrift.TClient) *InteractionServerClient {
	return &InteractionServerClient{
		c: c,
	}
}

func (p *InteractionServerClient) Client_() thrift.TClient {
	return p.c
}

func (p *InteractionServerClient) Favorite(ctx context.Context, req *DouyinFavoriteActionRequest) (r *DouyinFavoriteActionResponse, err error) {
	var _args InteractionServerFavoriteArgs
	_args.Req = req
	var _result InteractionServerFavoriteResult
	if err = p.Client_().Call(ctx, "Favorite", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) GetFavoriteVideoIdList(ctx context.Context, req *DouyinGetFavoriteVideoIdListRequest) (r *DouyinGetFavoriteVideoIdListResponse, err error) {
	var _args InteractionServerGetFavoriteVideoIdListArgs
	_args.Req = req
	var _result InteractionServerGetFavoriteVideoIdListResult
	if err = p.Client_().Call(ctx, "GetFavoriteVideoIdList", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) Comment(ctx context.Context, req *DouyinCommentActionRequest) (r *DouyinCommentActionResponse, err error) {
	var _args InteractionServerCommentArgs
	_args.Req = req
	var _result InteractionServerCommentResult
	if err = p.Client_().Call(ctx, "Comment", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) GetCommentList(ctx context.Context, req *DouyinGetCommentListRequest) (r *DouyinGetCommentListResponse, err error) {
	var _args InteractionServerGetCommentListArgs
	_args.Req = req
	var _result InteractionServerGetCommentListResult
	if err = p.Client_().Call(ctx, "GetCommentList", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) GetVideoInteractInfo(ctx context.Context, req *DouyinGetVideoInteractInfoRequest) (r *DouyinGetVideoInteractInfoResponse, err error) {
	var _args InteractionServerGetVideoInteractInfoArgs
	_args.Req = req
	var _result InteractionServerGetVideoInteractInfoResult
	if err = p.Client_().Call(ctx, "GetVideoInteractInfo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) BatchGetVideoInteractInfo(ctx context.Context, req *DouyinBatchGetVideoInteractInfoRequest) (r *DouyinBatchGetVideoInteractInfoResponse, err error) {
	var _args InteractionServerBatchGetVideoInteractInfoArgs
	_args.Req = req
	var _result InteractionServerBatchGetVideoInteractInfoResult
	if err = p.Client_().Call(ctx, "BatchGetVideoInteractInfo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) GetUserInteractInfo(ctx context.Context, req *DouyinGetUserInteractInfoRequest) (r *DouyinGetUserInteractInfoResponse, err error) {
	var _args InteractionServerGetUserInteractInfoArgs
	_args.Req = req
	var _result InteractionServerGetUserInteractInfoResult
	if err = p.Client_().Call(ctx, "GetUserInteractInfo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}
func (p *InteractionServerClient) BatchGetUserInteractInfo(ctx context.Context, req *DouyinBatchGetUserInteractInfoRequest) (r *DouyinBatchGetUserInteractInfoResponse, err error) {
	var _args InteractionServerBatchGetUserInteractInfoArgs
	_args.Req = req
	var _result InteractionServerBatchGetUserInteractInfoResult
	if err = p.Client_().Call(ctx, "BatchGetUserInteractInfo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

type InteractionServerProcessor struct {
	processorMap map[string]thrift.TProcessorFunction
	handler      InteractionServer
}

func (p *InteractionServerProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
	p.processorMap[key] = processor
}

func (p *InteractionServerProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
	processor, ok = p.processorMap[key]
	return processor, ok
}

func (p *InteractionServerProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
	return p.processorMap
}

func NewInteractionServerProcessor(handler InteractionServer) *InteractionServerProcessor {
	self := &InteractionServerProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
	self.AddToProcessorMap("Favorite", &interactionServerProcessorFavorite{handler: handler})
	self.AddToProcessorMap("GetFavoriteVideoIdList", &interactionServerProcessorGetFavoriteVideoIdList{handler: handler})
	self.AddToProcessorMap("Comment", &interactionServerProcessorComment{handler: handler})
	self.AddToProcessorMap("GetCommentList", &interactionServerProcessorGetCommentList{handler: handler})
	self.AddToProcessorMap("GetVideoInteractInfo", &interactionServerProcessorGetVideoInteractInfo{handler: handler})
	self.AddToProcessorMap("BatchGetVideoInteractInfo", &interactionServerProcessorBatchGetVideoInteractInfo{handler: handler})
	self.AddToProcessorMap("GetUserInteractInfo", &interactionServerProcessorGetUserInteractInfo{handler: handler})
	self.AddToProcessorMap("BatchGetUserInteractInfo", &interactionServerProcessorBatchGetUserInteractInfo{handler: handler})
	return self
}
func (p *InteractionServerProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	name, _, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return false, err
	}
	if processor, ok := p.GetProcessorFunction(name); ok {
		return processor.Process(ctx, seqId, iprot, oprot)
	}
	iprot.Skip(thrift.STRUCT)
	iprot.ReadMessageEnd()
	x := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
	oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
	x.Write(oprot)
	oprot.WriteMessageEnd()
	oprot.Flush(ctx)
	return false, x
}

type interactionServerProcessorFavorite struct {
	handler InteractionServer
}

func (p *interactionServerProcessorFavorite) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerFavoriteArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("Favorite", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerFavoriteResult{}
	var retval *DouyinFavoriteActionResponse
	if retval, err2 = p.handler.Favorite(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Favorite: "+err2.Error())
		oprot.WriteMessageBegin("Favorite", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("Favorite", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorGetFavoriteVideoIdList struct {
	handler InteractionServer
}

func (p *interactionServerProcessorGetFavoriteVideoIdList) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerGetFavoriteVideoIdListArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("GetFavoriteVideoIdList", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerGetFavoriteVideoIdListResult{}
	var retval *DouyinGetFavoriteVideoIdListResponse
	if retval, err2 = p.handler.GetFavoriteVideoIdList(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetFavoriteVideoIdList: "+err2.Error())
		oprot.WriteMessageBegin("GetFavoriteVideoIdList", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("GetFavoriteVideoIdList", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorComment struct {
	handler InteractionServer
}

func (p *interactionServerProcessorComment) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerCommentArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("Comment", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerCommentResult{}
	var retval *DouyinCommentActionResponse
	if retval, err2 = p.handler.Comment(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Comment: "+err2.Error())
		oprot.WriteMessageBegin("Comment", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("Comment", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorGetCommentList struct {
	handler InteractionServer
}

func (p *interactionServerProcessorGetCommentList) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerGetCommentListArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("GetCommentList", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerGetCommentListResult{}
	var retval *DouyinGetCommentListResponse
	if retval, err2 = p.handler.GetCommentList(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetCommentList: "+err2.Error())
		oprot.WriteMessageBegin("GetCommentList", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("GetCommentList", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorGetVideoInteractInfo struct {
	handler InteractionServer
}

func (p *interactionServerProcessorGetVideoInteractInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerGetVideoInteractInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("GetVideoInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerGetVideoInteractInfoResult{}
	var retval *DouyinGetVideoInteractInfoResponse
	if retval, err2 = p.handler.GetVideoInteractInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetVideoInteractInfo: "+err2.Error())
		oprot.WriteMessageBegin("GetVideoInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("GetVideoInteractInfo", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorBatchGetVideoInteractInfo struct {
	handler InteractionServer
}

func (p *interactionServerProcessorBatchGetVideoInteractInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerBatchGetVideoInteractInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("BatchGetVideoInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerBatchGetVideoInteractInfoResult{}
	var retval *DouyinBatchGetVideoInteractInfoResponse
	if retval, err2 = p.handler.BatchGetVideoInteractInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing BatchGetVideoInteractInfo: "+err2.Error())
		oprot.WriteMessageBegin("BatchGetVideoInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("BatchGetVideoInteractInfo", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorGetUserInteractInfo struct {
	handler InteractionServer
}

func (p *interactionServerProcessorGetUserInteractInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerGetUserInteractInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("GetUserInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerGetUserInteractInfoResult{}
	var retval *DouyinGetUserInteractInfoResponse
	if retval, err2 = p.handler.GetUserInteractInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetUserInteractInfo: "+err2.Error())
		oprot.WriteMessageBegin("GetUserInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("GetUserInteractInfo", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type interactionServerProcessorBatchGetUserInteractInfo struct {
	handler InteractionServer
}

func (p *interactionServerProcessorBatchGetUserInteractInfo) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := InteractionServerBatchGetUserInteractInfoArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("BatchGetUserInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	result := InteractionServerBatchGetUserInteractInfoResult{}
	var retval *DouyinBatchGetUserInteractInfoResponse
	if retval, err2 = p.handler.BatchGetUserInteractInfo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing BatchGetUserInteractInfo: "+err2.Error())
		oprot.WriteMessageBegin("BatchGetUserInteractInfo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("BatchGetUserInteractInfo", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type InteractionServerFavoriteArgs struct {
	Req *DouyinFavoriteActionRequest `thrift:"req,1" frugal:"1,default,DouyinFavoriteActionRequest" json:"req"`
}

func NewInteractionServerFavoriteArgs() *InteractionServerFavoriteArgs {
	return &InteractionServerFavoriteArgs{}
}

func (p *InteractionServerFavoriteArgs) InitDefault() {
	*p = InteractionServerFavoriteArgs{}
}

var InteractionServerFavoriteArgs_Req_DEFAULT *DouyinFavoriteActionRequest

func (p *InteractionServerFavoriteArgs) GetReq() (v *DouyinFavoriteActionRequest) {
	if !p.IsSetReq() {
		return InteractionServerFavoriteArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerFavoriteArgs) SetReq(val *DouyinFavoriteActionRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerFavoriteArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerFavoriteArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerFavoriteArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerFavoriteArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerFavoriteArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinFavoriteActionRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerFavoriteArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Favorite_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerFavoriteArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerFavoriteArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerFavoriteArgs(%+v)", *p)
}

func (p *InteractionServerFavoriteArgs) DeepEqual(ano *InteractionServerFavoriteArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerFavoriteArgs) Field1DeepEqual(src *DouyinFavoriteActionRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerFavoriteResult struct {
	Success *DouyinFavoriteActionResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinFavoriteActionResponse" json:"success,omitempty"`
}

func NewInteractionServerFavoriteResult() *InteractionServerFavoriteResult {
	return &InteractionServerFavoriteResult{}
}

func (p *InteractionServerFavoriteResult) InitDefault() {
	*p = InteractionServerFavoriteResult{}
}

var InteractionServerFavoriteResult_Success_DEFAULT *DouyinFavoriteActionResponse

func (p *InteractionServerFavoriteResult) GetSuccess() (v *DouyinFavoriteActionResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerFavoriteResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerFavoriteResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinFavoriteActionResponse)
}

var fieldIDToName_InteractionServerFavoriteResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerFavoriteResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerFavoriteResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerFavoriteResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerFavoriteResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinFavoriteActionResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerFavoriteResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Favorite_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerFavoriteResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerFavoriteResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerFavoriteResult(%+v)", *p)
}

func (p *InteractionServerFavoriteResult) DeepEqual(ano *InteractionServerFavoriteResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerFavoriteResult) Field0DeepEqual(src *DouyinFavoriteActionResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetFavoriteVideoIdListArgs struct {
	Req *DouyinGetFavoriteVideoIdListRequest `thrift:"req,1" frugal:"1,default,DouyinGetFavoriteVideoIdListRequest" json:"req"`
}

func NewInteractionServerGetFavoriteVideoIdListArgs() *InteractionServerGetFavoriteVideoIdListArgs {
	return &InteractionServerGetFavoriteVideoIdListArgs{}
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) InitDefault() {
	*p = InteractionServerGetFavoriteVideoIdListArgs{}
}

var InteractionServerGetFavoriteVideoIdListArgs_Req_DEFAULT *DouyinGetFavoriteVideoIdListRequest

func (p *InteractionServerGetFavoriteVideoIdListArgs) GetReq() (v *DouyinGetFavoriteVideoIdListRequest) {
	if !p.IsSetReq() {
		return InteractionServerGetFavoriteVideoIdListArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerGetFavoriteVideoIdListArgs) SetReq(val *DouyinGetFavoriteVideoIdListRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerGetFavoriteVideoIdListArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetFavoriteVideoIdListArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinGetFavoriteVideoIdListRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetFavoriteVideoIdList_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetFavoriteVideoIdListArgs(%+v)", *p)
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) DeepEqual(ano *InteractionServerGetFavoriteVideoIdListArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerGetFavoriteVideoIdListArgs) Field1DeepEqual(src *DouyinGetFavoriteVideoIdListRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetFavoriteVideoIdListResult struct {
	Success *DouyinGetFavoriteVideoIdListResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinGetFavoriteVideoIdListResponse" json:"success,omitempty"`
}

func NewInteractionServerGetFavoriteVideoIdListResult() *InteractionServerGetFavoriteVideoIdListResult {
	return &InteractionServerGetFavoriteVideoIdListResult{}
}

func (p *InteractionServerGetFavoriteVideoIdListResult) InitDefault() {
	*p = InteractionServerGetFavoriteVideoIdListResult{}
}

var InteractionServerGetFavoriteVideoIdListResult_Success_DEFAULT *DouyinGetFavoriteVideoIdListResponse

func (p *InteractionServerGetFavoriteVideoIdListResult) GetSuccess() (v *DouyinGetFavoriteVideoIdListResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerGetFavoriteVideoIdListResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerGetFavoriteVideoIdListResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinGetFavoriteVideoIdListResponse)
}

var fieldIDToName_InteractionServerGetFavoriteVideoIdListResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerGetFavoriteVideoIdListResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerGetFavoriteVideoIdListResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetFavoriteVideoIdListResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinGetFavoriteVideoIdListResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetFavoriteVideoIdListResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetFavoriteVideoIdList_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerGetFavoriteVideoIdListResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetFavoriteVideoIdListResult(%+v)", *p)
}

func (p *InteractionServerGetFavoriteVideoIdListResult) DeepEqual(ano *InteractionServerGetFavoriteVideoIdListResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerGetFavoriteVideoIdListResult) Field0DeepEqual(src *DouyinGetFavoriteVideoIdListResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerCommentArgs struct {
	Req *DouyinCommentActionRequest `thrift:"req,1" frugal:"1,default,DouyinCommentActionRequest" json:"req"`
}

func NewInteractionServerCommentArgs() *InteractionServerCommentArgs {
	return &InteractionServerCommentArgs{}
}

func (p *InteractionServerCommentArgs) InitDefault() {
	*p = InteractionServerCommentArgs{}
}

var InteractionServerCommentArgs_Req_DEFAULT *DouyinCommentActionRequest

func (p *InteractionServerCommentArgs) GetReq() (v *DouyinCommentActionRequest) {
	if !p.IsSetReq() {
		return InteractionServerCommentArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerCommentArgs) SetReq(val *DouyinCommentActionRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerCommentArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerCommentArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerCommentArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerCommentArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerCommentArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinCommentActionRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerCommentArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Comment_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerCommentArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerCommentArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerCommentArgs(%+v)", *p)
}

func (p *InteractionServerCommentArgs) DeepEqual(ano *InteractionServerCommentArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerCommentArgs) Field1DeepEqual(src *DouyinCommentActionRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerCommentResult struct {
	Success *DouyinCommentActionResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinCommentActionResponse" json:"success,omitempty"`
}

func NewInteractionServerCommentResult() *InteractionServerCommentResult {
	return &InteractionServerCommentResult{}
}

func (p *InteractionServerCommentResult) InitDefault() {
	*p = InteractionServerCommentResult{}
}

var InteractionServerCommentResult_Success_DEFAULT *DouyinCommentActionResponse

func (p *InteractionServerCommentResult) GetSuccess() (v *DouyinCommentActionResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerCommentResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerCommentResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinCommentActionResponse)
}

var fieldIDToName_InteractionServerCommentResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerCommentResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerCommentResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerCommentResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerCommentResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinCommentActionResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerCommentResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Comment_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerCommentResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerCommentResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerCommentResult(%+v)", *p)
}

func (p *InteractionServerCommentResult) DeepEqual(ano *InteractionServerCommentResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerCommentResult) Field0DeepEqual(src *DouyinCommentActionResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetCommentListArgs struct {
	Req *DouyinGetCommentListRequest `thrift:"req,1" frugal:"1,default,DouyinGetCommentListRequest" json:"req"`
}

func NewInteractionServerGetCommentListArgs() *InteractionServerGetCommentListArgs {
	return &InteractionServerGetCommentListArgs{}
}

func (p *InteractionServerGetCommentListArgs) InitDefault() {
	*p = InteractionServerGetCommentListArgs{}
}

var InteractionServerGetCommentListArgs_Req_DEFAULT *DouyinGetCommentListRequest

func (p *InteractionServerGetCommentListArgs) GetReq() (v *DouyinGetCommentListRequest) {
	if !p.IsSetReq() {
		return InteractionServerGetCommentListArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerGetCommentListArgs) SetReq(val *DouyinGetCommentListRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerGetCommentListArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerGetCommentListArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerGetCommentListArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetCommentListArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetCommentListArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinGetCommentListRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetCommentListArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetCommentList_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetCommentListArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerGetCommentListArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetCommentListArgs(%+v)", *p)
}

func (p *InteractionServerGetCommentListArgs) DeepEqual(ano *InteractionServerGetCommentListArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerGetCommentListArgs) Field1DeepEqual(src *DouyinGetCommentListRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetCommentListResult struct {
	Success *DouyinGetCommentListResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinGetCommentListResponse" json:"success,omitempty"`
}

func NewInteractionServerGetCommentListResult() *InteractionServerGetCommentListResult {
	return &InteractionServerGetCommentListResult{}
}

func (p *InteractionServerGetCommentListResult) InitDefault() {
	*p = InteractionServerGetCommentListResult{}
}

var InteractionServerGetCommentListResult_Success_DEFAULT *DouyinGetCommentListResponse

func (p *InteractionServerGetCommentListResult) GetSuccess() (v *DouyinGetCommentListResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerGetCommentListResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerGetCommentListResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinGetCommentListResponse)
}

var fieldIDToName_InteractionServerGetCommentListResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerGetCommentListResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerGetCommentListResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetCommentListResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetCommentListResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinGetCommentListResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetCommentListResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetCommentList_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetCommentListResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerGetCommentListResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetCommentListResult(%+v)", *p)
}

func (p *InteractionServerGetCommentListResult) DeepEqual(ano *InteractionServerGetCommentListResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerGetCommentListResult) Field0DeepEqual(src *DouyinGetCommentListResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetVideoInteractInfoArgs struct {
	Req *DouyinGetVideoInteractInfoRequest `thrift:"req,1" frugal:"1,default,DouyinGetVideoInteractInfoRequest" json:"req"`
}

func NewInteractionServerGetVideoInteractInfoArgs() *InteractionServerGetVideoInteractInfoArgs {
	return &InteractionServerGetVideoInteractInfoArgs{}
}

func (p *InteractionServerGetVideoInteractInfoArgs) InitDefault() {
	*p = InteractionServerGetVideoInteractInfoArgs{}
}

var InteractionServerGetVideoInteractInfoArgs_Req_DEFAULT *DouyinGetVideoInteractInfoRequest

func (p *InteractionServerGetVideoInteractInfoArgs) GetReq() (v *DouyinGetVideoInteractInfoRequest) {
	if !p.IsSetReq() {
		return InteractionServerGetVideoInteractInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerGetVideoInteractInfoArgs) SetReq(val *DouyinGetVideoInteractInfoRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerGetVideoInteractInfoArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerGetVideoInteractInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerGetVideoInteractInfoArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetVideoInteractInfoArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinGetVideoInteractInfoRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetVideoInteractInfoArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetVideoInteractInfo_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetVideoInteractInfoArgs(%+v)", *p)
}

func (p *InteractionServerGetVideoInteractInfoArgs) DeepEqual(ano *InteractionServerGetVideoInteractInfoArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerGetVideoInteractInfoArgs) Field1DeepEqual(src *DouyinGetVideoInteractInfoRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetVideoInteractInfoResult struct {
	Success *DouyinGetVideoInteractInfoResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinGetVideoInteractInfoResponse" json:"success,omitempty"`
}

func NewInteractionServerGetVideoInteractInfoResult() *InteractionServerGetVideoInteractInfoResult {
	return &InteractionServerGetVideoInteractInfoResult{}
}

func (p *InteractionServerGetVideoInteractInfoResult) InitDefault() {
	*p = InteractionServerGetVideoInteractInfoResult{}
}

var InteractionServerGetVideoInteractInfoResult_Success_DEFAULT *DouyinGetVideoInteractInfoResponse

func (p *InteractionServerGetVideoInteractInfoResult) GetSuccess() (v *DouyinGetVideoInteractInfoResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerGetVideoInteractInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerGetVideoInteractInfoResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinGetVideoInteractInfoResponse)
}

var fieldIDToName_InteractionServerGetVideoInteractInfoResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerGetVideoInteractInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerGetVideoInteractInfoResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetVideoInteractInfoResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinGetVideoInteractInfoResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetVideoInteractInfoResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetVideoInteractInfo_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerGetVideoInteractInfoResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetVideoInteractInfoResult(%+v)", *p)
}

func (p *InteractionServerGetVideoInteractInfoResult) DeepEqual(ano *InteractionServerGetVideoInteractInfoResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerGetVideoInteractInfoResult) Field0DeepEqual(src *DouyinGetVideoInteractInfoResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerBatchGetVideoInteractInfoArgs struct {
	Req *DouyinBatchGetVideoInteractInfoRequest `thrift:"req,1" frugal:"1,default,DouyinBatchGetVideoInteractInfoRequest" json:"req"`
}

func NewInteractionServerBatchGetVideoInteractInfoArgs() *InteractionServerBatchGetVideoInteractInfoArgs {
	return &InteractionServerBatchGetVideoInteractInfoArgs{}
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) InitDefault() {
	*p = InteractionServerBatchGetVideoInteractInfoArgs{}
}

var InteractionServerBatchGetVideoInteractInfoArgs_Req_DEFAULT *DouyinBatchGetVideoInteractInfoRequest

func (p *InteractionServerBatchGetVideoInteractInfoArgs) GetReq() (v *DouyinBatchGetVideoInteractInfoRequest) {
	if !p.IsSetReq() {
		return InteractionServerBatchGetVideoInteractInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerBatchGetVideoInteractInfoArgs) SetReq(val *DouyinBatchGetVideoInteractInfoRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerBatchGetVideoInteractInfoArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerBatchGetVideoInteractInfoArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinBatchGetVideoInteractInfoRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("BatchGetVideoInteractInfo_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerBatchGetVideoInteractInfoArgs(%+v)", *p)
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) DeepEqual(ano *InteractionServerBatchGetVideoInteractInfoArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerBatchGetVideoInteractInfoArgs) Field1DeepEqual(src *DouyinBatchGetVideoInteractInfoRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerBatchGetVideoInteractInfoResult struct {
	Success *DouyinBatchGetVideoInteractInfoResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinBatchGetVideoInteractInfoResponse" json:"success,omitempty"`
}

func NewInteractionServerBatchGetVideoInteractInfoResult() *InteractionServerBatchGetVideoInteractInfoResult {
	return &InteractionServerBatchGetVideoInteractInfoResult{}
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) InitDefault() {
	*p = InteractionServerBatchGetVideoInteractInfoResult{}
}

var InteractionServerBatchGetVideoInteractInfoResult_Success_DEFAULT *DouyinBatchGetVideoInteractInfoResponse

func (p *InteractionServerBatchGetVideoInteractInfoResult) GetSuccess() (v *DouyinBatchGetVideoInteractInfoResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerBatchGetVideoInteractInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerBatchGetVideoInteractInfoResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinBatchGetVideoInteractInfoResponse)
}

var fieldIDToName_InteractionServerBatchGetVideoInteractInfoResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerBatchGetVideoInteractInfoResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinBatchGetVideoInteractInfoResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("BatchGetVideoInteractInfo_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerBatchGetVideoInteractInfoResult(%+v)", *p)
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) DeepEqual(ano *InteractionServerBatchGetVideoInteractInfoResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerBatchGetVideoInteractInfoResult) Field0DeepEqual(src *DouyinBatchGetVideoInteractInfoResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetUserInteractInfoArgs struct {
	Req *DouyinGetUserInteractInfoRequest `thrift:"req,1" frugal:"1,default,DouyinGetUserInteractInfoRequest" json:"req"`
}

func NewInteractionServerGetUserInteractInfoArgs() *InteractionServerGetUserInteractInfoArgs {
	return &InteractionServerGetUserInteractInfoArgs{}
}

func (p *InteractionServerGetUserInteractInfoArgs) InitDefault() {
	*p = InteractionServerGetUserInteractInfoArgs{}
}

var InteractionServerGetUserInteractInfoArgs_Req_DEFAULT *DouyinGetUserInteractInfoRequest

func (p *InteractionServerGetUserInteractInfoArgs) GetReq() (v *DouyinGetUserInteractInfoRequest) {
	if !p.IsSetReq() {
		return InteractionServerGetUserInteractInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerGetUserInteractInfoArgs) SetReq(val *DouyinGetUserInteractInfoRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerGetUserInteractInfoArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerGetUserInteractInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerGetUserInteractInfoArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetUserInteractInfoArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinGetUserInteractInfoRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetUserInteractInfoArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetUserInteractInfo_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetUserInteractInfoArgs(%+v)", *p)
}

func (p *InteractionServerGetUserInteractInfoArgs) DeepEqual(ano *InteractionServerGetUserInteractInfoArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerGetUserInteractInfoArgs) Field1DeepEqual(src *DouyinGetUserInteractInfoRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerGetUserInteractInfoResult struct {
	Success *DouyinGetUserInteractInfoResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinGetUserInteractInfoResponse" json:"success,omitempty"`
}

func NewInteractionServerGetUserInteractInfoResult() *InteractionServerGetUserInteractInfoResult {
	return &InteractionServerGetUserInteractInfoResult{}
}

func (p *InteractionServerGetUserInteractInfoResult) InitDefault() {
	*p = InteractionServerGetUserInteractInfoResult{}
}

var InteractionServerGetUserInteractInfoResult_Success_DEFAULT *DouyinGetUserInteractInfoResponse

func (p *InteractionServerGetUserInteractInfoResult) GetSuccess() (v *DouyinGetUserInteractInfoResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerGetUserInteractInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerGetUserInteractInfoResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinGetUserInteractInfoResponse)
}

var fieldIDToName_InteractionServerGetUserInteractInfoResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerGetUserInteractInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerGetUserInteractInfoResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerGetUserInteractInfoResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinGetUserInteractInfoResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerGetUserInteractInfoResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("GetUserInteractInfo_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerGetUserInteractInfoResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerGetUserInteractInfoResult(%+v)", *p)
}

func (p *InteractionServerGetUserInteractInfoResult) DeepEqual(ano *InteractionServerGetUserInteractInfoResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerGetUserInteractInfoResult) Field0DeepEqual(src *DouyinGetUserInteractInfoResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerBatchGetUserInteractInfoArgs struct {
	Req *DouyinBatchGetUserInteractInfoRequest `thrift:"req,1" frugal:"1,default,DouyinBatchGetUserInteractInfoRequest" json:"req"`
}

func NewInteractionServerBatchGetUserInteractInfoArgs() *InteractionServerBatchGetUserInteractInfoArgs {
	return &InteractionServerBatchGetUserInteractInfoArgs{}
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) InitDefault() {
	*p = InteractionServerBatchGetUserInteractInfoArgs{}
}

var InteractionServerBatchGetUserInteractInfoArgs_Req_DEFAULT *DouyinBatchGetUserInteractInfoRequest

func (p *InteractionServerBatchGetUserInteractInfoArgs) GetReq() (v *DouyinBatchGetUserInteractInfoRequest) {
	if !p.IsSetReq() {
		return InteractionServerBatchGetUserInteractInfoArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *InteractionServerBatchGetUserInteractInfoArgs) SetReq(val *DouyinBatchGetUserInteractInfoRequest) {
	p.Req = val
}

var fieldIDToName_InteractionServerBatchGetUserInteractInfoArgs = map[int16]string{
	1: "req",
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) IsSetReq() bool {
	return p.Req != nil
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerBatchGetUserInteractInfoArgs[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDouyinBatchGetUserInteractInfoRequest()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("BatchGetUserInteractInfo_args"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Req.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerBatchGetUserInteractInfoArgs(%+v)", *p)
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) DeepEqual(ano *InteractionServerBatchGetUserInteractInfoArgs) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Req) {
		return false
	}
	return true
}

func (p *InteractionServerBatchGetUserInteractInfoArgs) Field1DeepEqual(src *DouyinBatchGetUserInteractInfoRequest) bool {

	if !p.Req.DeepEqual(src) {
		return false
	}
	return true
}

type InteractionServerBatchGetUserInteractInfoResult struct {
	Success *DouyinBatchGetUserInteractInfoResponse `thrift:"success,0,optional" frugal:"0,optional,DouyinBatchGetUserInteractInfoResponse" json:"success,omitempty"`
}

func NewInteractionServerBatchGetUserInteractInfoResult() *InteractionServerBatchGetUserInteractInfoResult {
	return &InteractionServerBatchGetUserInteractInfoResult{}
}

func (p *InteractionServerBatchGetUserInteractInfoResult) InitDefault() {
	*p = InteractionServerBatchGetUserInteractInfoResult{}
}

var InteractionServerBatchGetUserInteractInfoResult_Success_DEFAULT *DouyinBatchGetUserInteractInfoResponse

func (p *InteractionServerBatchGetUserInteractInfoResult) GetSuccess() (v *DouyinBatchGetUserInteractInfoResponse) {
	if !p.IsSetSuccess() {
		return InteractionServerBatchGetUserInteractInfoResult_Success_DEFAULT
	}
	return p.Success
}
func (p *InteractionServerBatchGetUserInteractInfoResult) SetSuccess(x interface{}) {
	p.Success = x.(*DouyinBatchGetUserInteractInfoResponse)
}

var fieldIDToName_InteractionServerBatchGetUserInteractInfoResult = map[int16]string{
	0: "success",
}

func (p *InteractionServerBatchGetUserInteractInfoResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *InteractionServerBatchGetUserInteractInfoResult) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField0(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InteractionServerBatchGetUserInteractInfoResult[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDouyinBatchGetUserInteractInfoResponse()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *InteractionServerBatchGetUserInteractInfoResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("BatchGetUserInteractInfo_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Success.Write(oprot); err != nil {
			return err
		}
		if err = oprot.WriteFieldEnd(); err != nil {
			goto WriteFieldEndError
		}
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err)
}

func (p *InteractionServerBatchGetUserInteractInfoResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InteractionServerBatchGetUserInteractInfoResult(%+v)", *p)
}

func (p *InteractionServerBatchGetUserInteractInfoResult) DeepEqual(ano *InteractionServerBatchGetUserInteractInfoResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field0DeepEqual(ano.Success) {
		return false
	}
	return true
}

func (p *InteractionServerBatchGetUserInteractInfoResult) Field0DeepEqual(src *DouyinBatchGetUserInteractInfoResponse) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}