github.com/cloudwego/dynamicgo@v0.2.6-0.20240519101509-707f41b6b834/testdata/kitex_gen/example/example.go

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

package example

import (
	"github.com/cloudwego/dynamicgo/testdata/kitex_gen/base"
	"github.com/cloudwego/dynamicgo/testdata/kitex_gen/deep"
	"context"
	"database/sql"
	"database/sql/driver"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
	"strings"
)

type FOO int64

const (
	FOO_B FOO = 0
	FOO_A FOO = 1
)

func (p FOO) String() string {
	switch p {
	case FOO_B:
		return "B"
	case FOO_A:
		return "A"
	}
	return "<UNSET>"
}

func FOOFromString(s string) (FOO, error) {
	switch s {
	case "B":
		return FOO_B, nil
	case "A":
		return FOO_A, nil
	}
	return FOO(0), fmt.Errorf("not a valid FOO string")
}

func FOOPtr(v FOO) *FOO { return &v }

func (p *FOO) Scan(value interface{}) (err error) {
	var result sql.NullInt64
	err = result.Scan(value)
	*p = FOO(result.Int64)
	return
}

func (p *FOO) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type ExampleReq struct {
	Msg       *string    `thrift:"Msg,1" json:"Msg,omitempty"`
	InnerBase int32      `thrift:"InnerBase,3" json:"InnerBase"`
	Base      *base.Base `thrift:"Base,255,required" json:"Base"`
	Subfix    float64    `thrift:"Subfix,32767" json:"Subfix"`
}

func NewExampleReq() *ExampleReq {
	return &ExampleReq{}
}

var ExampleReq_Msg_DEFAULT string

func (p *ExampleReq) GetMsg() (v string) {
	if !p.IsSetMsg() {
		return ExampleReq_Msg_DEFAULT
	}
	return *p.Msg
}

func (p *ExampleReq) GetInnerBase() (v int32) {
	return p.InnerBase
}

var ExampleReq_Base_DEFAULT *base.Base

func (p *ExampleReq) GetBase() (v *base.Base) {
	if !p.IsSetBase() {
		return ExampleReq_Base_DEFAULT
	}
	return p.Base
}

func (p *ExampleReq) GetSubfix() (v float64) {
	return p.Subfix
}
func (p *ExampleReq) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleReq) SetInnerBase(val int32) {
	p.InnerBase = val
}
func (p *ExampleReq) SetBase(val *base.Base) {
	p.Base = val
}
func (p *ExampleReq) SetSubfix(val float64) {
	p.Subfix = val
}

var fieldIDToName_ExampleReq = map[int16]string{
	1:     "Msg",
	3:     "InnerBase",
	255:   "Base",
	32767: "Subfix",
}

func (p *ExampleReq) IsSetMsg() bool {
	return p.Msg != nil
}

func (p *ExampleReq) IsSetBase() bool {
	return p.Base != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetBase bool = false

	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.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 255:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField255(iprot); err != nil {
					goto ReadFieldError
				}
				issetBase = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 32767:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField32767(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
	}

	if !issetBase {
		fieldId = 255
		goto RequiredFieldNotSetError
	}
	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_ExampleReq[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)
RequiredFieldNotSetError:
	return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field %s is not set", fieldIDToName_ExampleReq[fieldId]))
}

func (p *ExampleReq) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = &v
	}
	return nil
}

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

func (p *ExampleReq) ReadField255(iprot thrift.TProtocol) error {
	p.Base = base.NewBase()
	if err := p.Base.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleReq) ReadField32767(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Subfix = v
	}
	return nil
}

func (p *ExampleReq) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleReq"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField3(oprot); err != nil {
			fieldId = 3
			goto WriteFieldError
		}
		if err = p.writeField255(oprot); err != nil {
			fieldId = 255
			goto WriteFieldError
		}
		if err = p.writeField32767(oprot); err != nil {
			fieldId = 32767
			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 *ExampleReq) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetMsg() {
		if err = oprot.WriteFieldBegin("Msg", thrift.STRING, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Msg); 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 *ExampleReq) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerBase", thrift.I32, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.InnerBase); 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 *ExampleReq) writeField255(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Base.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 255 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err)
}

func (p *ExampleReq) writeField32767(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Subfix", thrift.DOUBLE, 32767); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Subfix); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 32767 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 32767 end error: ", p), err)
}

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

func (p *ExampleReq) DeepEqual(ano *ExampleReq) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Msg) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field255DeepEqual(ano.Base) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	return true
}

func (p *ExampleReq) Field1DeepEqual(src *string) bool {

	if p.Msg == src {
		return true
	} else if p.Msg == nil || src == nil {
		return false
	}
	if strings.Compare(*p.Msg, *src) != 0 {
		return false
	}
	return true
}
func (p *ExampleReq) Field3DeepEqual(src int32) bool {

	if p.InnerBase != src {
		return false
	}
	return true
}
func (p *ExampleReq) Field255DeepEqual(src *base.Base) bool {

	if !p.Base.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleReq) Field32767DeepEqual(src float64) bool {

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

type ExampleToSnakeCase struct {
	Msg       *string    `thrift:"Msg,1" json:"Msg,omitempty"`
	ReqList   []string   `thrift:"req_list,2" json:"req_list"`
	InnerBase int32      `thrift:"InnerBase,3" json:"InnerBase"`
	Base      *base.Base `thrift:"Base,255,required" json:"Base"`
}

func NewExampleToSnakeCase() *ExampleToSnakeCase {
	return &ExampleToSnakeCase{}
}

var ExampleToSnakeCase_Msg_DEFAULT string

func (p *ExampleToSnakeCase) GetMsg() (v string) {
	if !p.IsSetMsg() {
		return ExampleToSnakeCase_Msg_DEFAULT
	}
	return *p.Msg
}

func (p *ExampleToSnakeCase) GetReqList() (v []string) {
	return p.ReqList
}

func (p *ExampleToSnakeCase) GetInnerBase() (v int32) {
	return p.InnerBase
}

var ExampleToSnakeCase_Base_DEFAULT *base.Base

func (p *ExampleToSnakeCase) GetBase() (v *base.Base) {
	if !p.IsSetBase() {
		return ExampleToSnakeCase_Base_DEFAULT
	}
	return p.Base
}
func (p *ExampleToSnakeCase) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleToSnakeCase) SetReqList(val []string) {
	p.ReqList = val
}
func (p *ExampleToSnakeCase) SetInnerBase(val int32) {
	p.InnerBase = val
}
func (p *ExampleToSnakeCase) SetBase(val *base.Base) {
	p.Base = val
}

var fieldIDToName_ExampleToSnakeCase = map[int16]string{
	1:   "Msg",
	2:   "req_list",
	3:   "InnerBase",
	255: "Base",
}

func (p *ExampleToSnakeCase) IsSetMsg() bool {
	return p.Msg != nil
}

func (p *ExampleToSnakeCase) IsSetBase() bool {
	return p.Base != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetBase bool = false

	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.STRING {
				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
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 255:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField255(iprot); err != nil {
					goto ReadFieldError
				}
				issetBase = true
			} 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
	}

	if !issetBase {
		fieldId = 255
		goto RequiredFieldNotSetError
	}
	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_ExampleToSnakeCase[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)
RequiredFieldNotSetError:
	return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field %s is not set", fieldIDToName_ExampleToSnakeCase[fieldId]))
}

func (p *ExampleToSnakeCase) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = &v
	}
	return nil
}

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

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

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

func (p *ExampleToSnakeCase) ReadField255(iprot thrift.TProtocol) error {
	p.Base = base.NewBase()
	if err := p.Base.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleToSnakeCase) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleToSnakeCase"); 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.writeField255(oprot); err != nil {
			fieldId = 255
			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 *ExampleToSnakeCase) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetMsg() {
		if err = oprot.WriteFieldBegin("Msg", thrift.STRING, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Msg); 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 *ExampleToSnakeCase) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("req_list", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.ReqList)); err != nil {
		return err
	}
	for _, v := range p.ReqList {
		if err := oprot.WriteString(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 *ExampleToSnakeCase) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerBase", thrift.I32, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.InnerBase); 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 *ExampleToSnakeCase) writeField255(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Base.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 255 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err)
}

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

func (p *ExampleToSnakeCase) DeepEqual(ano *ExampleToSnakeCase) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Msg) {
		return false
	}
	if !p.Field2DeepEqual(ano.ReqList) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field255DeepEqual(ano.Base) {
		return false
	}
	return true
}

func (p *ExampleToSnakeCase) Field1DeepEqual(src *string) bool {

	if p.Msg == src {
		return true
	} else if p.Msg == nil || src == nil {
		return false
	}
	if strings.Compare(*p.Msg, *src) != 0 {
		return false
	}
	return true
}
func (p *ExampleToSnakeCase) Field2DeepEqual(src []string) bool {

	if len(p.ReqList) != len(src) {
		return false
	}
	for i, v := range p.ReqList {
		_src := src[i]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *ExampleToSnakeCase) Field3DeepEqual(src int32) bool {

	if p.InnerBase != src {
		return false
	}
	return true
}
func (p *ExampleToSnakeCase) Field255DeepEqual(src *base.Base) bool {

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

type ExampleResp struct {
	Msg           *string        `thrift:"Msg,1" json:"Msg,omitempty"`
	RequiredField string         `thrift:"required_field,2,required" json:"required_field"`
	BaseResp      *base.BaseResp `thrift:"BaseResp,32767" json:"BaseResp"`
}

func NewExampleResp() *ExampleResp {
	return &ExampleResp{}
}

var ExampleResp_Msg_DEFAULT string

func (p *ExampleResp) GetMsg() (v string) {
	if !p.IsSetMsg() {
		return ExampleResp_Msg_DEFAULT
	}
	return *p.Msg
}

func (p *ExampleResp) GetRequiredField() (v string) {
	return p.RequiredField
}

var ExampleResp_BaseResp_DEFAULT *base.BaseResp

func (p *ExampleResp) GetBaseResp() (v *base.BaseResp) {
	if !p.IsSetBaseResp() {
		return ExampleResp_BaseResp_DEFAULT
	}
	return p.BaseResp
}
func (p *ExampleResp) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleResp) SetRequiredField(val string) {
	p.RequiredField = val
}
func (p *ExampleResp) SetBaseResp(val *base.BaseResp) {
	p.BaseResp = val
}

var fieldIDToName_ExampleResp = map[int16]string{
	1:     "Msg",
	2:     "required_field",
	32767: "BaseResp",
}

func (p *ExampleResp) IsSetMsg() bool {
	return p.Msg != nil
}

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

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetRequiredField bool = false

	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.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
				issetRequiredField = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 32767:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField32767(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
	}

	if !issetRequiredField {
		fieldId = 2
		goto RequiredFieldNotSetError
	}
	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_ExampleResp[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)
RequiredFieldNotSetError:
	return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field %s is not set", fieldIDToName_ExampleResp[fieldId]))
}

func (p *ExampleResp) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = &v
	}
	return nil
}

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

func (p *ExampleResp) ReadField32767(iprot thrift.TProtocol) error {
	p.BaseResp = base.NewBaseResp()
	if err := p.BaseResp.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleResp) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleResp"); 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.writeField32767(oprot); err != nil {
			fieldId = 32767
			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 *ExampleResp) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetMsg() {
		if err = oprot.WriteFieldBegin("Msg", thrift.STRING, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Msg); 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 *ExampleResp) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("required_field", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.RequiredField); 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 *ExampleResp) writeField32767(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 32767); 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 32767 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 32767 end error: ", p), err)
}

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

func (p *ExampleResp) DeepEqual(ano *ExampleResp) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Msg) {
		return false
	}
	if !p.Field2DeepEqual(ano.RequiredField) {
		return false
	}
	if !p.Field32767DeepEqual(ano.BaseResp) {
		return false
	}
	return true
}

func (p *ExampleResp) Field1DeepEqual(src *string) bool {

	if p.Msg == src {
		return true
	} else if p.Msg == nil || src == nil {
		return false
	}
	if strings.Compare(*p.Msg, *src) != 0 {
		return false
	}
	return true
}
func (p *ExampleResp) Field2DeepEqual(src string) bool {

	if strings.Compare(p.RequiredField, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleResp) Field32767DeepEqual(src *base.BaseResp) bool {

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

type A struct {
	Self string `thrift:"self,1" json:"self"`
	Foo  FOO    `thrift:"foo,2" json:"foo"`
}

func NewA() *A {
	return &A{}
}

func (p *A) GetSelf() (v string) {
	return p.Self
}

func (p *A) GetFoo() (v FOO) {
	return p.Foo
}
func (p *A) SetSelf(val string) {
	p.Self = val
}
func (p *A) SetFoo(val FOO) {
	p.Foo = val
}

var fieldIDToName_A = map[int16]string{
	1: "self",
	2: "foo",
}

func (p *A) 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.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				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_A[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 *A) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Self = v
	}
	return nil
}

func (p *A) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.Foo = FOO(v)
	}
	return nil
}

func (p *A) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("A"); 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 *A) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("self", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Self); 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 *A) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("foo", thrift.I32, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(int32(p.Foo)); 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 *A) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("A(%+v)", *p)
}

func (p *A) DeepEqual(ano *A) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Self) {
		return false
	}
	if !p.Field2DeepEqual(ano.Foo) {
		return false
	}
	return true
}

func (p *A) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Self, src) != 0 {
		return false
	}
	return true
}
func (p *A) Field2DeepEqual(src FOO) bool {

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

type ExampleDefaultValue struct {
	String_     string            `thrift:"String,1" json:"String"`
	Int         int32             `thrift:"Int,2" json:"Int"`
	Double      float64           `thrift:"Double,3" json:"Double"`
	Bool        bool              `thrift:"Bool,4" json:"Bool"`
	List        []string          `thrift:"List,5" json:"List"`
	Map         map[string]string `thrift:"Map,6" json:"Map"`
	Set         []string          `thrift:"Set,7" json:"Set"`
	ConstString string            `thrift:"ConstString,8" json:"ConstString"`
	Enum        FOO               `thrift:"Enum,9" json:"Enum"`
}

func NewExampleDefaultValue() *ExampleDefaultValue {
	return &ExampleDefaultValue{

		String_: "default",
		Int:     1,
		Double:  1.1,
		Bool:    true,
		List: []string{
			"a",
			"b",
		},
		Map: map[string]string{
			"a": "b",
		},
		Set: []string{
			"a",
			"b",
		},
		ConstString: deep.ConstString,
		Enum:        FOO_A,
	}
}

func (p *ExampleDefaultValue) GetString() (v string) {
	return p.String_
}

func (p *ExampleDefaultValue) GetInt() (v int32) {
	return p.Int
}

func (p *ExampleDefaultValue) GetDouble() (v float64) {
	return p.Double
}

func (p *ExampleDefaultValue) GetBool() (v bool) {
	return p.Bool
}

func (p *ExampleDefaultValue) GetList() (v []string) {
	return p.List
}

func (p *ExampleDefaultValue) GetMap() (v map[string]string) {
	return p.Map
}

func (p *ExampleDefaultValue) GetSet() (v []string) {
	return p.Set
}

func (p *ExampleDefaultValue) GetConstString() (v string) {
	return p.ConstString
}

func (p *ExampleDefaultValue) GetEnum() (v FOO) {
	return p.Enum
}
func (p *ExampleDefaultValue) SetString(val string) {
	p.String_ = val
}
func (p *ExampleDefaultValue) SetInt(val int32) {
	p.Int = val
}
func (p *ExampleDefaultValue) SetDouble(val float64) {
	p.Double = val
}
func (p *ExampleDefaultValue) SetBool(val bool) {
	p.Bool = val
}
func (p *ExampleDefaultValue) SetList(val []string) {
	p.List = val
}
func (p *ExampleDefaultValue) SetMap(val map[string]string) {
	p.Map = val
}
func (p *ExampleDefaultValue) SetSet(val []string) {
	p.Set = val
}
func (p *ExampleDefaultValue) SetConstString(val string) {
	p.ConstString = val
}
func (p *ExampleDefaultValue) SetEnum(val FOO) {
	p.Enum = val
}

var fieldIDToName_ExampleDefaultValue = map[int16]string{
	1: "String",
	2: "Int",
	3: "Double",
	4: "Bool",
	5: "List",
	6: "Map",
	7: "Set",
	8: "ConstString",
	9: "Enum",
}

func (p *ExampleDefaultValue) 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.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.BOOL {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 7:
			if fieldTypeId == thrift.SET {
				if err = p.ReadField7(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 8:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField8(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 9:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField9(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_ExampleDefaultValue[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 *ExampleDefaultValue) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.String_ = v
	}
	return nil
}

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

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

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

func (p *ExampleDefaultValue) ReadField5(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.List = make([]string, 0, size)
	for i := 0; i < size; i++ {
		var _elem string
		if v, err := iprot.ReadString(); err != nil {
			return err
		} else {
			_elem = v
		}

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

func (p *ExampleDefaultValue) ReadField6(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.Map = make(map[string]string, size)
	for i := 0; i < size; i++ {
		var _key string
		if v, err := iprot.ReadString(); err != nil {
			return err
		} else {
			_key = v
		}

		var _val string
		if v, err := iprot.ReadString(); err != nil {
			return err
		} else {
			_val = v
		}

		p.Map[_key] = _val
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return err
	}
	return nil
}

func (p *ExampleDefaultValue) ReadField7(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return err
	}
	p.Set = make([]string, 0, size)
	for i := 0; i < size; i++ {
		var _elem string
		if v, err := iprot.ReadString(); err != nil {
			return err
		} else {
			_elem = v
		}

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

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

func (p *ExampleDefaultValue) ReadField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.Enum = FOO(v)
	}
	return nil
}

func (p *ExampleDefaultValue) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleDefaultValue"); 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 = p.writeField6(oprot); err != nil {
			fieldId = 6
			goto WriteFieldError
		}
		if err = p.writeField7(oprot); err != nil {
			fieldId = 7
			goto WriteFieldError
		}
		if err = p.writeField8(oprot); err != nil {
			fieldId = 8
			goto WriteFieldError
		}
		if err = p.writeField9(oprot); err != nil {
			fieldId = 9
			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 *ExampleDefaultValue) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("String", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.String_); 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 *ExampleDefaultValue) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int", thrift.I32, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Int); 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 *ExampleDefaultValue) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Double", thrift.DOUBLE, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Double); 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 *ExampleDefaultValue) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Bool", thrift.BOOL, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteBool(p.Bool); 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 *ExampleDefaultValue) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("List", thrift.LIST, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.List)); err != nil {
		return err
	}
	for _, v := range p.List {
		if err := oprot.WriteString(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 5 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err)
}

func (p *ExampleDefaultValue) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Map", thrift.MAP, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.Map)); err != nil {
		return err
	}
	for k, v := range p.Map {

		if err := oprot.WriteString(k); err != nil {
			return err
		}

		if err := oprot.WriteString(v); err != nil {
			return err
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *ExampleDefaultValue) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Set", thrift.SET, 7); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteSetBegin(thrift.STRING, len(p.Set)); err != nil {
		return err
	}
	for i := 0; i < len(p.Set); i++ {
		for j := i + 1; j < len(p.Set); j++ {
			if func(tgt, src string) bool {
				if strings.Compare(tgt, src) != 0 {
					return false
				}
				return true
			}(p.Set[i], p.Set[j]) {
				return thrift.PrependError("", fmt.Errorf("%T error writing set field: slice is not unique", p.Set[i]))
			}
		}
	}
	for _, v := range p.Set {
		if err := oprot.WriteString(v); err != nil {
			return err
		}
	}
	if err := oprot.WriteSetEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err)
}

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

func (p *ExampleDefaultValue) writeField9(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Enum", thrift.I32, 9); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(int32(p.Enum)); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 9 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 9 end error: ", p), err)
}

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

func (p *ExampleDefaultValue) DeepEqual(ano *ExampleDefaultValue) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.String_) {
		return false
	}
	if !p.Field2DeepEqual(ano.Int) {
		return false
	}
	if !p.Field3DeepEqual(ano.Double) {
		return false
	}
	if !p.Field4DeepEqual(ano.Bool) {
		return false
	}
	if !p.Field5DeepEqual(ano.List) {
		return false
	}
	if !p.Field6DeepEqual(ano.Map) {
		return false
	}
	if !p.Field7DeepEqual(ano.Set) {
		return false
	}
	if !p.Field8DeepEqual(ano.ConstString) {
		return false
	}
	if !p.Field9DeepEqual(ano.Enum) {
		return false
	}
	return true
}

func (p *ExampleDefaultValue) Field1DeepEqual(src string) bool {

	if strings.Compare(p.String_, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleDefaultValue) Field2DeepEqual(src int32) bool {

	if p.Int != src {
		return false
	}
	return true
}
func (p *ExampleDefaultValue) Field3DeepEqual(src float64) bool {

	if p.Double != src {
		return false
	}
	return true
}
func (p *ExampleDefaultValue) Field4DeepEqual(src bool) bool {

	if p.Bool != src {
		return false
	}
	return true
}
func (p *ExampleDefaultValue) Field5DeepEqual(src []string) bool {

	if len(p.List) != len(src) {
		return false
	}
	for i, v := range p.List {
		_src := src[i]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *ExampleDefaultValue) Field6DeepEqual(src map[string]string) bool {

	if len(p.Map) != len(src) {
		return false
	}
	for k, v := range p.Map {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *ExampleDefaultValue) Field7DeepEqual(src []string) bool {

	if len(p.Set) != len(src) {
		return false
	}
	for i, v := range p.Set {
		_src := src[i]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *ExampleDefaultValue) Field8DeepEqual(src string) bool {

	if strings.Compare(p.ConstString, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleDefaultValue) Field9DeepEqual(src FOO) bool {

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

type DeepRef struct {
	DeepRef *deep.TestStruct `thrift:"DeepRef,1" json:"DeepRef"`
}

func NewDeepRef() *DeepRef {
	return &DeepRef{}
}

var DeepRef_DeepRef_DEFAULT *deep.TestStruct

func (p *DeepRef) GetDeepRef() (v *deep.TestStruct) {
	if !p.IsSetDeepRef() {
		return DeepRef_DeepRef_DEFAULT
	}
	return p.DeepRef
}
func (p *DeepRef) SetDeepRef(val *deep.TestStruct) {
	p.DeepRef = val
}

var fieldIDToName_DeepRef = map[int16]string{
	1: "DeepRef",
}

func (p *DeepRef) IsSetDeepRef() bool {
	return p.DeepRef != nil
}

func (p *DeepRef) 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_DeepRef[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 *DeepRef) ReadField1(iprot thrift.TProtocol) error {
	p.DeepRef = deep.NewTestStruct()
	if err := p.DeepRef.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *DeepRef) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("DeepRef"); 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 *DeepRef) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("DeepRef", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.DeepRef.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 *DeepRef) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("DeepRef(%+v)", *p)
}

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

func (p *DeepRef) Field1DeepEqual(src *deep.TestStruct) bool {

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

type Exception struct {
	Code int32  `thrift:"code,1" json:"code"`
	Msg  string `thrift:"msg,255" json:"msg"`
}

func NewException() *Exception {
	return &Exception{}
}

func (p *Exception) GetCode() (v int32) {
	return p.Code
}

func (p *Exception) GetMsg() (v string) {
	return p.Msg
}
func (p *Exception) SetCode(val int32) {
	p.Code = val
}
func (p *Exception) SetMsg(val string) {
	p.Msg = val
}

var fieldIDToName_Exception = map[int16]string{
	1:   "code",
	255: "msg",
}

func (p *Exception) 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.I32 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 255:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField255(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_Exception[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 *Exception) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.Code = v
	}
	return nil
}

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

func (p *Exception) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Exception"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField255(oprot); err != nil {
			fieldId = 255
			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 *Exception) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("code", thrift.I32, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Code); 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 *Exception) writeField255(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("msg", thrift.STRING, 255); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Msg); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err)
}

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

func (p *Exception) DeepEqual(ano *Exception) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Code) {
		return false
	}
	if !p.Field255DeepEqual(ano.Msg) {
		return false
	}
	return true
}

func (p *Exception) Field1DeepEqual(src int32) bool {

	if p.Code != src {
		return false
	}
	return true
}
func (p *Exception) Field255DeepEqual(src string) bool {

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}

type ExampleService interface {
	ExampleDeepRef(ctx context.Context, req *DeepRef) (r *DeepRef, err error)

	ExampleMethod(ctx context.Context, req *ExampleReq) (r *ExampleResp, err error)

	Foo(ctx context.Context, req *A) (r *A, err error)

	Ping(ctx context.Context, msg string) (r string, err error)

	Oneway(ctx context.Context, msg string) (err error)

	Void(ctx context.Context, msg string) (err error)

	ExampleToSnakeCase(ctx context.Context, req *ExampleToSnakeCase) (err error)

	ExampleDefaultValue(ctx context.Context, req *ExampleDefaultValue) (r *ExampleDefaultValue, err error)
}

type ExampleServiceClient struct {
	c thrift.TClient
}

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

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

func NewExampleServiceClient(c thrift.TClient) *ExampleServiceClient {
	return &ExampleServiceClient{
		c: c,
	}
}

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

func (p *ExampleServiceClient) ExampleDeepRef(ctx context.Context, req *DeepRef) (r *DeepRef, err error) {
	var _args ExampleServiceExampleDeepRefArgs
	_args.Req = req
	var _result ExampleServiceExampleDeepRefResult
	if err = p.Client_().Call(ctx, "ExampleDeepRef", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *ExampleServiceClient) ExampleMethod(ctx context.Context, req *ExampleReq) (r *ExampleResp, err error) {
	var _args ExampleServiceExampleMethodArgs
	_args.Req = req
	var _result ExampleServiceExampleMethodResult
	if err = p.Client_().Call(ctx, "ExampleMethod", &_args, &_result); err != nil {
		return
	}
	switch {
	case _result.Err != nil:
		return r, _result.Err
	}
	return _result.GetSuccess(), nil
}

func (p *ExampleServiceClient) Foo(ctx context.Context, req *A) (r *A, err error) {
	var _args ExampleServiceFooArgs
	_args.Req = req
	var _result ExampleServiceFooResult
	if err = p.Client_().Call(ctx, "Foo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *ExampleServiceClient) Ping(ctx context.Context, msg string) (r string, err error) {
	var _args ExampleServicePingArgs
	_args.Msg = msg
	var _result ExampleServicePingResult
	if err = p.Client_().Call(ctx, "Ping", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *ExampleServiceClient) Oneway(ctx context.Context, msg string) (err error) {
	var _args ExampleServiceOnewayArgs
	_args.Msg = msg
	if err = p.Client_().Call(ctx, "Oneway", &_args, nil); err != nil {
		return
	}
	return nil
}

func (p *ExampleServiceClient) Void(ctx context.Context, msg string) (err error) {
	var _args ExampleServiceVoidArgs
	_args.Msg = msg
	var _result ExampleServiceVoidResult
	if err = p.Client_().Call(ctx, "Void", &_args, &_result); err != nil {
		return
	}
	return nil
}

func (p *ExampleServiceClient) ExampleToSnakeCase(ctx context.Context, req *ExampleToSnakeCase) (err error) {
	var _args ExampleServiceExampleToSnakeCaseArgs
	_args.Req = req
	var _result ExampleServiceExampleToSnakeCaseResult
	if err = p.Client_().Call(ctx, "ExampleToSnakeCase", &_args, &_result); err != nil {
		return
	}
	return nil
}

func (p *ExampleServiceClient) ExampleDefaultValue(ctx context.Context, req *ExampleDefaultValue) (r *ExampleDefaultValue, err error) {
	var _args ExampleServiceExampleDefaultValueArgs
	_args.Req = req
	var _result ExampleServiceExampleDefaultValueResult
	if err = p.Client_().Call(ctx, "ExampleDefaultValue", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

type ExampleServiceProcessor struct {
	processorMap map[string]thrift.TProcessorFunction
	handler      ExampleService
}

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

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

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

func NewExampleServiceProcessor(handler ExampleService) *ExampleServiceProcessor {
	self := &ExampleServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
	self.AddToProcessorMap("ExampleDeepRef", &exampleServiceProcessorExampleDeepRef{handler: handler})
	self.AddToProcessorMap("ExampleMethod", &exampleServiceProcessorExampleMethod{handler: handler})
	self.AddToProcessorMap("Foo", &exampleServiceProcessorFoo{handler: handler})
	self.AddToProcessorMap("Ping", &exampleServiceProcessorPing{handler: handler})
	self.AddToProcessorMap("Oneway", &exampleServiceProcessorOneway{handler: handler})
	self.AddToProcessorMap("Void", &exampleServiceProcessorVoid{handler: handler})
	self.AddToProcessorMap("ExampleToSnakeCase", &exampleServiceProcessorExampleToSnakeCase{handler: handler})
	self.AddToProcessorMap("ExampleDefaultValue", &exampleServiceProcessorExampleDefaultValue{handler: handler})
	return self
}
func (p *ExampleServiceProcessor) 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 exampleServiceProcessorExampleDeepRef struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceExampleDeepRefResult{}
	var retval *DeepRef
	if retval, err2 = p.handler.ExampleDeepRef(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ExampleDeepRef: "+err2.Error())
		oprot.WriteMessageBegin("ExampleDeepRef", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("ExampleDeepRef", 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 exampleServiceProcessorExampleMethod struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceExampleMethodResult{}
	var retval *ExampleResp
	if retval, err2 = p.handler.ExampleMethod(ctx, args.Req); err2 != nil {
		switch v := err2.(type) {
		case *Exception:
			result.Err = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ExampleMethod: "+err2.Error())
			oprot.WriteMessageBegin("ExampleMethod", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush(ctx)
			return true, err2
		}
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("ExampleMethod", 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 exampleServiceProcessorFoo struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceFooResult{}
	var retval *A
	if retval, err2 = p.handler.Foo(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Foo: "+err2.Error())
		oprot.WriteMessageBegin("Foo", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("Foo", 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 exampleServiceProcessorPing struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServicePingResult{}
	var retval string
	if retval, err2 = p.handler.Ping(ctx, args.Msg); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Ping: "+err2.Error())
		oprot.WriteMessageBegin("Ping", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = &retval
	}
	if err2 = oprot.WriteMessageBegin("Ping", 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 exampleServiceProcessorOneway struct {
	handler ExampleService
}

func (p *exampleServiceProcessorOneway) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExampleServiceOnewayArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	if err2 = p.handler.Oneway(ctx, args.Msg); err2 != nil {
		return true, err2
	}
	return true, nil
}

type exampleServiceProcessorVoid struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceVoidResult{}
	if err2 = p.handler.Void(ctx, args.Msg); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Void: "+err2.Error())
		oprot.WriteMessageBegin("Void", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	}
	if err2 = oprot.WriteMessageBegin("Void", 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 exampleServiceProcessorExampleToSnakeCase struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceExampleToSnakeCaseResult{}
	if err2 = p.handler.ExampleToSnakeCase(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ExampleToSnakeCase: "+err2.Error())
		oprot.WriteMessageBegin("ExampleToSnakeCase", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	}
	if err2 = oprot.WriteMessageBegin("ExampleToSnakeCase", 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 exampleServiceProcessorExampleDefaultValue struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceExampleDefaultValueResult{}
	var retval *ExampleDefaultValue
	if retval, err2 = p.handler.ExampleDefaultValue(ctx, args.Req); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ExampleDefaultValue: "+err2.Error())
		oprot.WriteMessageBegin("ExampleDefaultValue", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("ExampleDefaultValue", 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 ExampleServiceExampleDeepRefArgs struct {
	Req *DeepRef `thrift:"req,1" json:"req"`
}

func NewExampleServiceExampleDeepRefArgs() *ExampleServiceExampleDeepRefArgs {
	return &ExampleServiceExampleDeepRefArgs{}
}

var ExampleServiceExampleDeepRefArgs_Req_DEFAULT *DeepRef

func (p *ExampleServiceExampleDeepRefArgs) GetReq() (v *DeepRef) {
	if !p.IsSetReq() {
		return ExampleServiceExampleDeepRefArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExampleDeepRefArgs) SetReq(val *DeepRef) {
	p.Req = val
}

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

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

func (p *ExampleServiceExampleDeepRefArgs) 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_ExampleServiceExampleDeepRefArgs[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 *ExampleServiceExampleDeepRefArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewDeepRef()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleDeepRefArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleDeepRef_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 *ExampleServiceExampleDeepRefArgs) 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 *ExampleServiceExampleDeepRefArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleDeepRefArgs(%+v)", *p)
}

func (p *ExampleServiceExampleDeepRefArgs) DeepEqual(ano *ExampleServiceExampleDeepRefArgs) 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 *ExampleServiceExampleDeepRefArgs) Field1DeepEqual(src *DeepRef) bool {

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

type ExampleServiceExampleDeepRefResult struct {
	Success *DeepRef `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceExampleDeepRefResult() *ExampleServiceExampleDeepRefResult {
	return &ExampleServiceExampleDeepRefResult{}
}

var ExampleServiceExampleDeepRefResult_Success_DEFAULT *DeepRef

func (p *ExampleServiceExampleDeepRefResult) GetSuccess() (v *DeepRef) {
	if !p.IsSetSuccess() {
		return ExampleServiceExampleDeepRefResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceExampleDeepRefResult) SetSuccess(x interface{}) {
	p.Success = x.(*DeepRef)
}

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

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

func (p *ExampleServiceExampleDeepRefResult) 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_ExampleServiceExampleDeepRefResult[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 *ExampleServiceExampleDeepRefResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewDeepRef()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleDeepRefResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleDeepRef_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 *ExampleServiceExampleDeepRefResult) 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 *ExampleServiceExampleDeepRefResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleDeepRefResult(%+v)", *p)
}

func (p *ExampleServiceExampleDeepRefResult) DeepEqual(ano *ExampleServiceExampleDeepRefResult) 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 *ExampleServiceExampleDeepRefResult) Field0DeepEqual(src *DeepRef) bool {

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

type ExampleServiceExampleMethodArgs struct {
	Req *ExampleReq `thrift:"req,1" json:"req"`
}

func NewExampleServiceExampleMethodArgs() *ExampleServiceExampleMethodArgs {
	return &ExampleServiceExampleMethodArgs{}
}

var ExampleServiceExampleMethodArgs_Req_DEFAULT *ExampleReq

func (p *ExampleServiceExampleMethodArgs) GetReq() (v *ExampleReq) {
	if !p.IsSetReq() {
		return ExampleServiceExampleMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExampleMethodArgs) SetReq(val *ExampleReq) {
	p.Req = val
}

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

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

func (p *ExampleServiceExampleMethodArgs) 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_ExampleServiceExampleMethodArgs[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 *ExampleServiceExampleMethodArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewExampleReq()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleMethodArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleMethod_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 *ExampleServiceExampleMethodArgs) 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 *ExampleServiceExampleMethodArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleMethodArgs(%+v)", *p)
}

func (p *ExampleServiceExampleMethodArgs) DeepEqual(ano *ExampleServiceExampleMethodArgs) 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 *ExampleServiceExampleMethodArgs) Field1DeepEqual(src *ExampleReq) bool {

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

type ExampleServiceExampleMethodResult struct {
	Success *ExampleResp `thrift:"success,0" json:"success,omitempty"`
	Err     *Exception   `thrift:"err,1" json:"err,omitempty"`
}

func NewExampleServiceExampleMethodResult() *ExampleServiceExampleMethodResult {
	return &ExampleServiceExampleMethodResult{}
}

var ExampleServiceExampleMethodResult_Success_DEFAULT *ExampleResp

func (p *ExampleServiceExampleMethodResult) GetSuccess() (v *ExampleResp) {
	if !p.IsSetSuccess() {
		return ExampleServiceExampleMethodResult_Success_DEFAULT
	}
	return p.Success
}

var ExampleServiceExampleMethodResult_Err_DEFAULT *Exception

func (p *ExampleServiceExampleMethodResult) GetErr() (v *Exception) {
	if !p.IsSetErr() {
		return ExampleServiceExampleMethodResult_Err_DEFAULT
	}
	return p.Err
}
func (p *ExampleServiceExampleMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleResp)
}
func (p *ExampleServiceExampleMethodResult) SetErr(val *Exception) {
	p.Err = val
}

var fieldIDToName_ExampleServiceExampleMethodResult = map[int16]string{
	0: "success",
	1: "err",
}

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

func (p *ExampleServiceExampleMethodResult) IsSetErr() bool {
	return p.Err != nil
}

func (p *ExampleServiceExampleMethodResult) 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
				}
			}
		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_ExampleServiceExampleMethodResult[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 *ExampleServiceExampleMethodResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewExampleResp()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleMethodResult) ReadField1(iprot thrift.TProtocol) error {
	p.Err = NewException()
	if err := p.Err.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleMethodResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleMethod_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField0(oprot); err != nil {
			fieldId = 0
			goto WriteFieldError
		}
		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 *ExampleServiceExampleMethodResult) 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 *ExampleServiceExampleMethodResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErr() {
		if err = oprot.WriteFieldBegin("err", thrift.STRUCT, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := p.Err.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 *ExampleServiceExampleMethodResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleMethodResult(%+v)", *p)
}

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

func (p *ExampleServiceExampleMethodResult) Field0DeepEqual(src *ExampleResp) bool {

	if !p.Success.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleServiceExampleMethodResult) Field1DeepEqual(src *Exception) bool {

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

type ExampleServiceFooArgs struct {
	Req *A `thrift:"req,1" json:"req"`
}

func NewExampleServiceFooArgs() *ExampleServiceFooArgs {
	return &ExampleServiceFooArgs{}
}

var ExampleServiceFooArgs_Req_DEFAULT *A

func (p *ExampleServiceFooArgs) GetReq() (v *A) {
	if !p.IsSetReq() {
		return ExampleServiceFooArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceFooArgs) SetReq(val *A) {
	p.Req = val
}

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

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

func (p *ExampleServiceFooArgs) 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_ExampleServiceFooArgs[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 *ExampleServiceFooArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewA()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceFooArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Foo_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 *ExampleServiceFooArgs) 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 *ExampleServiceFooArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceFooArgs(%+v)", *p)
}

func (p *ExampleServiceFooArgs) DeepEqual(ano *ExampleServiceFooArgs) 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 *ExampleServiceFooArgs) Field1DeepEqual(src *A) bool {

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

type ExampleServiceFooResult struct {
	Success *A `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceFooResult() *ExampleServiceFooResult {
	return &ExampleServiceFooResult{}
}

var ExampleServiceFooResult_Success_DEFAULT *A

func (p *ExampleServiceFooResult) GetSuccess() (v *A) {
	if !p.IsSetSuccess() {
		return ExampleServiceFooResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceFooResult) SetSuccess(x interface{}) {
	p.Success = x.(*A)
}

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

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

func (p *ExampleServiceFooResult) 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_ExampleServiceFooResult[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 *ExampleServiceFooResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewA()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceFooResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Foo_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 *ExampleServiceFooResult) 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 *ExampleServiceFooResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceFooResult(%+v)", *p)
}

func (p *ExampleServiceFooResult) DeepEqual(ano *ExampleServiceFooResult) 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 *ExampleServiceFooResult) Field0DeepEqual(src *A) bool {

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

type ExampleServicePingArgs struct {
	Msg string `thrift:"msg,1" json:"msg"`
}

func NewExampleServicePingArgs() *ExampleServicePingArgs {
	return &ExampleServicePingArgs{}
}

func (p *ExampleServicePingArgs) GetMsg() (v string) {
	return p.Msg
}
func (p *ExampleServicePingArgs) SetMsg(val string) {
	p.Msg = val
}

var fieldIDToName_ExampleServicePingArgs = map[int16]string{
	1: "msg",
}

func (p *ExampleServicePingArgs) 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.STRING {
				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_ExampleServicePingArgs[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 *ExampleServicePingArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = v
	}
	return nil
}

func (p *ExampleServicePingArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Ping_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 *ExampleServicePingArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("msg", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Msg); 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 *ExampleServicePingArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServicePingArgs(%+v)", *p)
}

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

func (p *ExampleServicePingArgs) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}

type ExampleServicePingResult struct {
	Success *string `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServicePingResult() *ExampleServicePingResult {
	return &ExampleServicePingResult{}
}

var ExampleServicePingResult_Success_DEFAULT string

func (p *ExampleServicePingResult) GetSuccess() (v string) {
	if !p.IsSetSuccess() {
		return ExampleServicePingResult_Success_DEFAULT
	}
	return *p.Success
}
func (p *ExampleServicePingResult) SetSuccess(x interface{}) {
	p.Success = x.(*string)
}

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

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

func (p *ExampleServicePingResult) 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.STRING {
				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_ExampleServicePingResult[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 *ExampleServicePingResult) ReadField0(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Success = &v
	}
	return nil
}

func (p *ExampleServicePingResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Ping_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 *ExampleServicePingResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err = oprot.WriteFieldBegin("success", thrift.STRING, 0); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Success); 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 *ExampleServicePingResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServicePingResult(%+v)", *p)
}

func (p *ExampleServicePingResult) DeepEqual(ano *ExampleServicePingResult) 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 *ExampleServicePingResult) Field0DeepEqual(src *string) bool {

	if p.Success == src {
		return true
	} else if p.Success == nil || src == nil {
		return false
	}
	if strings.Compare(*p.Success, *src) != 0 {
		return false
	}
	return true
}

type ExampleServiceOnewayArgs struct {
	Msg string `thrift:"msg,1" json:"msg"`
}

func NewExampleServiceOnewayArgs() *ExampleServiceOnewayArgs {
	return &ExampleServiceOnewayArgs{}
}

func (p *ExampleServiceOnewayArgs) GetMsg() (v string) {
	return p.Msg
}
func (p *ExampleServiceOnewayArgs) SetMsg(val string) {
	p.Msg = val
}

var fieldIDToName_ExampleServiceOnewayArgs = map[int16]string{
	1: "msg",
}

func (p *ExampleServiceOnewayArgs) 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.STRING {
				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_ExampleServiceOnewayArgs[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 *ExampleServiceOnewayArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = v
	}
	return nil
}

func (p *ExampleServiceOnewayArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Oneway_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 *ExampleServiceOnewayArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("msg", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Msg); 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 *ExampleServiceOnewayArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceOnewayArgs(%+v)", *p)
}

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

func (p *ExampleServiceOnewayArgs) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}

type ExampleServiceVoidArgs struct {
	Msg string `thrift:"msg,1" json:"msg"`
}

func NewExampleServiceVoidArgs() *ExampleServiceVoidArgs {
	return &ExampleServiceVoidArgs{}
}

func (p *ExampleServiceVoidArgs) GetMsg() (v string) {
	return p.Msg
}
func (p *ExampleServiceVoidArgs) SetMsg(val string) {
	p.Msg = val
}

var fieldIDToName_ExampleServiceVoidArgs = map[int16]string{
	1: "msg",
}

func (p *ExampleServiceVoidArgs) 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.STRING {
				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_ExampleServiceVoidArgs[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 *ExampleServiceVoidArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = v
	}
	return nil
}

func (p *ExampleServiceVoidArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Void_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 *ExampleServiceVoidArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("msg", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Msg); 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 *ExampleServiceVoidArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceVoidArgs(%+v)", *p)
}

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

func (p *ExampleServiceVoidArgs) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}

type ExampleServiceVoidResult struct {
}

func NewExampleServiceVoidResult() *ExampleServiceVoidResult {
	return &ExampleServiceVoidResult{}
}

var fieldIDToName_ExampleServiceVoidResult = map[int16]string{}

func (p *ExampleServiceVoidResult) 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
		}
		if err = iprot.Skip(fieldTypeId); err != nil {
			goto SkipFieldTypeError
		}

		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)
SkipFieldTypeError:
	return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, 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 *ExampleServiceVoidResult) Write(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteStructBegin("Void_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {

	}
	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)
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 *ExampleServiceVoidResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceVoidResult(%+v)", *p)
}

func (p *ExampleServiceVoidResult) DeepEqual(ano *ExampleServiceVoidResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	return true
}

type ExampleServiceExampleToSnakeCaseArgs struct {
	Req *ExampleToSnakeCase `thrift:"req,1" json:"req"`
}

func NewExampleServiceExampleToSnakeCaseArgs() *ExampleServiceExampleToSnakeCaseArgs {
	return &ExampleServiceExampleToSnakeCaseArgs{}
}

var ExampleServiceExampleToSnakeCaseArgs_Req_DEFAULT *ExampleToSnakeCase

func (p *ExampleServiceExampleToSnakeCaseArgs) GetReq() (v *ExampleToSnakeCase) {
	if !p.IsSetReq() {
		return ExampleServiceExampleToSnakeCaseArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExampleToSnakeCaseArgs) SetReq(val *ExampleToSnakeCase) {
	p.Req = val
}

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

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

func (p *ExampleServiceExampleToSnakeCaseArgs) 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_ExampleServiceExampleToSnakeCaseArgs[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 *ExampleServiceExampleToSnakeCaseArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewExampleToSnakeCase()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleToSnakeCaseArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleToSnakeCase_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 *ExampleServiceExampleToSnakeCaseArgs) 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 *ExampleServiceExampleToSnakeCaseArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleToSnakeCaseArgs(%+v)", *p)
}

func (p *ExampleServiceExampleToSnakeCaseArgs) DeepEqual(ano *ExampleServiceExampleToSnakeCaseArgs) 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 *ExampleServiceExampleToSnakeCaseArgs) Field1DeepEqual(src *ExampleToSnakeCase) bool {

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

type ExampleServiceExampleToSnakeCaseResult struct {
}

func NewExampleServiceExampleToSnakeCaseResult() *ExampleServiceExampleToSnakeCaseResult {
	return &ExampleServiceExampleToSnakeCaseResult{}
}

var fieldIDToName_ExampleServiceExampleToSnakeCaseResult = map[int16]string{}

func (p *ExampleServiceExampleToSnakeCaseResult) 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
		}
		if err = iprot.Skip(fieldTypeId); err != nil {
			goto SkipFieldTypeError
		}

		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)
SkipFieldTypeError:
	return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, 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 *ExampleServiceExampleToSnakeCaseResult) Write(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteStructBegin("ExampleToSnakeCase_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {

	}
	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)
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 *ExampleServiceExampleToSnakeCaseResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleToSnakeCaseResult(%+v)", *p)
}

func (p *ExampleServiceExampleToSnakeCaseResult) DeepEqual(ano *ExampleServiceExampleToSnakeCaseResult) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	return true
}

type ExampleServiceExampleDefaultValueArgs struct {
	Req *ExampleDefaultValue `thrift:"req,1" json:"req"`
}

func NewExampleServiceExampleDefaultValueArgs() *ExampleServiceExampleDefaultValueArgs {
	return &ExampleServiceExampleDefaultValueArgs{}
}

var ExampleServiceExampleDefaultValueArgs_Req_DEFAULT *ExampleDefaultValue

func (p *ExampleServiceExampleDefaultValueArgs) GetReq() (v *ExampleDefaultValue) {
	if !p.IsSetReq() {
		return ExampleServiceExampleDefaultValueArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExampleDefaultValueArgs) SetReq(val *ExampleDefaultValue) {
	p.Req = val
}

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

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

func (p *ExampleServiceExampleDefaultValueArgs) 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_ExampleServiceExampleDefaultValueArgs[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 *ExampleServiceExampleDefaultValueArgs) ReadField1(iprot thrift.TProtocol) error {
	p.Req = NewExampleDefaultValue()
	if err := p.Req.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleDefaultValueArgs) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleDefaultValue_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 *ExampleServiceExampleDefaultValueArgs) 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 *ExampleServiceExampleDefaultValueArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleDefaultValueArgs(%+v)", *p)
}

func (p *ExampleServiceExampleDefaultValueArgs) DeepEqual(ano *ExampleServiceExampleDefaultValueArgs) 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 *ExampleServiceExampleDefaultValueArgs) Field1DeepEqual(src *ExampleDefaultValue) bool {

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

type ExampleServiceExampleDefaultValueResult struct {
	Success *ExampleDefaultValue `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceExampleDefaultValueResult() *ExampleServiceExampleDefaultValueResult {
	return &ExampleServiceExampleDefaultValueResult{}
}

var ExampleServiceExampleDefaultValueResult_Success_DEFAULT *ExampleDefaultValue

func (p *ExampleServiceExampleDefaultValueResult) GetSuccess() (v *ExampleDefaultValue) {
	if !p.IsSetSuccess() {
		return ExampleServiceExampleDefaultValueResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceExampleDefaultValueResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleDefaultValue)
}

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

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

func (p *ExampleServiceExampleDefaultValueResult) 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_ExampleServiceExampleDefaultValueResult[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 *ExampleServiceExampleDefaultValueResult) ReadField0(iprot thrift.TProtocol) error {
	p.Success = NewExampleDefaultValue()
	if err := p.Success.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleServiceExampleDefaultValueResult) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleDefaultValue_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 *ExampleServiceExampleDefaultValueResult) 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 *ExampleServiceExampleDefaultValueResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleServiceExampleDefaultValueResult(%+v)", *p)
}

func (p *ExampleServiceExampleDefaultValueResult) DeepEqual(ano *ExampleServiceExampleDefaultValueResult) 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 *ExampleServiceExampleDefaultValueResult) Field0DeepEqual(src *ExampleDefaultValue) bool {

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