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

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

package example3

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

type FOO int64

const (
	FOO_A FOO = 1
)

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

func FOOFromString(s string) (FOO, error) {
	switch s {
	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 InnerBase struct {
	Bool               bool                  `thrift:"Bool,1" json:"Bool"`
	Byte               int8                  `thrift:"Byte,2" json:"Byte"`
	Int16              int16                 `thrift:"Int16,3" json:"Int16"`
	Int32              int32                 `thrift:"Int32,4" json:"Int32"`
	Int64              int64                 `thrift:"Int64,5" json:"Int64"`
	Double             float64               `thrift:"Double,6" json:"Double"`
	String_            string                `thrift:"String,7" json:"String"`
	ListInt32          []int32               `thrift:"ListInt32,8" json:"ListInt32"`
	MapStringString    map[string]string     `thrift:"MapStringString,9" json:"MapStringString"`
	SetInt32_          []int32               `thrift:"SetInt32,10" json:"SetInt32"`
	Foo                FOO                   `thrift:"Foo,11" json:"Foo"`
	MapInt32String     map[int32]string      `thrift:"MapInt32String,12" json:"MapInt32String"`
	Binary             []byte                `thrift:"Binary,13" json:"Binary"`
	MapInt8String      map[int8]string       `thrift:"MapInt8String,14" json:"MapInt8String"`
	MapInt16String     map[int16]string      `thrift:"MapInt16String,15" json:"MapInt16String"`
	MapInt64String     map[int64]string      `thrift:"MapInt64String,16" json:"MapInt64String"`
	ListInnerBase      []*InnerBase          `thrift:"ListInnerBase,18" json:"ListInnerBase"`
	MapStringInnerBase map[string]*InnerBase `thrift:"MapStringInnerBase,19" json:"MapStringInnerBase"`
	InnerQuery         string                `thrift:"InnerQuery,20" json:"InnerQuery"`
	Base               *base.Base            `thrift:"Base,255" json:"Base"`
}

func NewInnerBase() *InnerBase {
	return &InnerBase{}
}

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

func (p *InnerBase) GetByte() (v int8) {
	return p.Byte
}

func (p *InnerBase) GetInt16() (v int16) {
	return p.Int16
}

func (p *InnerBase) GetInt32() (v int32) {
	return p.Int32
}

func (p *InnerBase) GetInt64() (v int64) {
	return p.Int64
}

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

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

func (p *InnerBase) GetListInt32() (v []int32) {
	return p.ListInt32
}

func (p *InnerBase) GetMapStringString() (v map[string]string) {
	return p.MapStringString
}

func (p *InnerBase) GetSetInt32() (v []int32) {
	return p.SetInt32_
}

func (p *InnerBase) GetFoo() (v FOO) {
	return p.Foo
}

func (p *InnerBase) GetMapInt32String() (v map[int32]string) {
	return p.MapInt32String
}

func (p *InnerBase) GetBinary() (v []byte) {
	return p.Binary
}

func (p *InnerBase) GetMapInt8String() (v map[int8]string) {
	return p.MapInt8String
}

func (p *InnerBase) GetMapInt16String() (v map[int16]string) {
	return p.MapInt16String
}

func (p *InnerBase) GetMapInt64String() (v map[int64]string) {
	return p.MapInt64String
}

func (p *InnerBase) GetListInnerBase() (v []*InnerBase) {
	return p.ListInnerBase
}

func (p *InnerBase) GetMapStringInnerBase() (v map[string]*InnerBase) {
	return p.MapStringInnerBase
}

func (p *InnerBase) GetInnerQuery() (v string) {
	return p.InnerQuery
}

var InnerBase_Base_DEFAULT *base.Base

func (p *InnerBase) GetBase() (v *base.Base) {
	if !p.IsSetBase() {
		return InnerBase_Base_DEFAULT
	}
	return p.Base
}
func (p *InnerBase) SetBool(val bool) {
	p.Bool = val
}
func (p *InnerBase) SetByte(val int8) {
	p.Byte = val
}
func (p *InnerBase) SetInt16(val int16) {
	p.Int16 = val
}
func (p *InnerBase) SetInt32(val int32) {
	p.Int32 = val
}
func (p *InnerBase) SetInt64(val int64) {
	p.Int64 = val
}
func (p *InnerBase) SetDouble(val float64) {
	p.Double = val
}
func (p *InnerBase) SetString(val string) {
	p.String_ = val
}
func (p *InnerBase) SetListInt32(val []int32) {
	p.ListInt32 = val
}
func (p *InnerBase) SetMapStringString(val map[string]string) {
	p.MapStringString = val
}
func (p *InnerBase) SetSetInt32(val []int32) {
	p.SetInt32_ = val
}
func (p *InnerBase) SetFoo(val FOO) {
	p.Foo = val
}
func (p *InnerBase) SetMapInt32String(val map[int32]string) {
	p.MapInt32String = val
}
func (p *InnerBase) SetBinary(val []byte) {
	p.Binary = val
}
func (p *InnerBase) SetMapInt8String(val map[int8]string) {
	p.MapInt8String = val
}
func (p *InnerBase) SetMapInt16String(val map[int16]string) {
	p.MapInt16String = val
}
func (p *InnerBase) SetMapInt64String(val map[int64]string) {
	p.MapInt64String = val
}
func (p *InnerBase) SetListInnerBase(val []*InnerBase) {
	p.ListInnerBase = val
}
func (p *InnerBase) SetMapStringInnerBase(val map[string]*InnerBase) {
	p.MapStringInnerBase = val
}
func (p *InnerBase) SetInnerQuery(val string) {
	p.InnerQuery = val
}
func (p *InnerBase) SetBase(val *base.Base) {
	p.Base = val
}

var fieldIDToName_InnerBase = map[int16]string{
	1:   "Bool",
	2:   "Byte",
	3:   "Int16",
	4:   "Int32",
	5:   "Int64",
	6:   "Double",
	7:   "String",
	8:   "ListInt32",
	9:   "MapStringString",
	10:  "SetInt32",
	11:  "Foo",
	12:  "MapInt32String",
	13:  "Binary",
	14:  "MapInt8String",
	15:  "MapInt16String",
	16:  "MapInt64String",
	18:  "ListInnerBase",
	19:  "MapStringInnerBase",
	20:  "InnerQuery",
	255: "Base",
}

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

func (p *InnerBase) 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.BOOL {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.BYTE {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.I16 {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 7:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField7(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 8:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField8(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 9:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField9(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 10:
			if fieldTypeId == thrift.SET {
				if err = p.ReadField10(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 11:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField11(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 12:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField12(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 13:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField13(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 14:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField14(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 15:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField15(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 16:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField16(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 18:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField18(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 19:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField19(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 20:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField20(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
				}
			} 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_InnerBase[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 *InnerBase) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return err
	} else {
		p.Bool = v
	}
	return nil
}

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

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

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

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

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

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

func (p *InnerBase) ReadField8(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.ListInt32 = make([]int32, 0, size)
	for i := 0; i < size; i++ {
		var _elem int32
		if v, err := iprot.ReadI32(); err != nil {
			return err
		} else {
			_elem = v
		}

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

func (p *InnerBase) ReadField9(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapStringString = 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.MapStringString[_key] = _val
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return err
	}
	return nil
}

func (p *InnerBase) ReadField10(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return err
	}
	p.SetInt32_ = make([]int32, 0, size)
	for i := 0; i < size; i++ {
		var _elem int32
		if v, err := iprot.ReadI32(); err != nil {
			return err
		} else {
			_elem = v
		}

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

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

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

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

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

func (p *InnerBase) ReadField13(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return err
	} else {
		p.Binary = []byte(v)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

func (p *InnerBase) ReadField18(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.ListInnerBase = make([]*InnerBase, 0, size)
	for i := 0; i < size; i++ {
		_elem := NewInnerBase()
		if err := _elem.Read(iprot); err != nil {
			return err
		}

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

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

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

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

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

func (p *InnerBase) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("InnerBase"); 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 = p.writeField10(oprot); err != nil {
			fieldId = 10
			goto WriteFieldError
		}
		if err = p.writeField11(oprot); err != nil {
			fieldId = 11
			goto WriteFieldError
		}
		if err = p.writeField12(oprot); err != nil {
			fieldId = 12
			goto WriteFieldError
		}
		if err = p.writeField13(oprot); err != nil {
			fieldId = 13
			goto WriteFieldError
		}
		if err = p.writeField14(oprot); err != nil {
			fieldId = 14
			goto WriteFieldError
		}
		if err = p.writeField15(oprot); err != nil {
			fieldId = 15
			goto WriteFieldError
		}
		if err = p.writeField16(oprot); err != nil {
			fieldId = 16
			goto WriteFieldError
		}
		if err = p.writeField18(oprot); err != nil {
			fieldId = 18
			goto WriteFieldError
		}
		if err = p.writeField19(oprot); err != nil {
			fieldId = 19
			goto WriteFieldError
		}
		if err = p.writeField20(oprot); err != nil {
			fieldId = 20
			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 *InnerBase) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Bool", thrift.BOOL, 1); 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 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *InnerBase) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Byte", thrift.BYTE, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteByte(p.Byte); 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 *InnerBase) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int16", thrift.I16, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI16(p.Int16); 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 *InnerBase) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int32", thrift.I32, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Int32); 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 *InnerBase) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int64", thrift.I64, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.Int64); 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 *InnerBase) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Double", thrift.DOUBLE, 6); 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 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *InnerBase) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("String", thrift.STRING, 7); 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 7 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err)
}

func (p *InnerBase) writeField8(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("ListInt32", thrift.LIST, 8); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.I32, len(p.ListInt32)); err != nil {
		return err
	}
	for _, v := range p.ListInt32 {
		if err := oprot.WriteI32(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 8 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 8 end error: ", p), err)
}

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

		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 9 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 9 end error: ", p), err)
}

func (p *InnerBase) writeField10(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("SetInt32", thrift.SET, 10); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteSetBegin(thrift.I32, len(p.SetInt32_)); err != nil {
		return err
	}
	for i := 0; i < len(p.SetInt32_); i++ {
		for j := i + 1; j < len(p.SetInt32_); j++ {
			if func(tgt, src int32) bool {
				if tgt != src {
					return false
				}
				return true
			}(p.SetInt32_[i], p.SetInt32_[j]) {
				return thrift.PrependError("", fmt.Errorf("%T error writing set field: slice is not unique", p.SetInt32_[i]))
			}
		}
	}
	for _, v := range p.SetInt32_ {
		if err := oprot.WriteI32(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 10 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 10 end error: ", p), err)
}

func (p *InnerBase) writeField11(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Foo", thrift.I32, 11); 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 11 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err)
}

func (p *InnerBase) writeField12(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapInt32String", thrift.MAP, 12); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.I32, thrift.STRING, len(p.MapInt32String)); err != nil {
		return err
	}
	for k, v := range p.MapInt32String {

		if err := oprot.WriteI32(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 12 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err)
}

func (p *InnerBase) writeField13(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Binary", thrift.STRING, 13); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteBinary([]byte(p.Binary)); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 13 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 13 end error: ", p), err)
}

func (p *InnerBase) writeField14(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapInt8String", thrift.MAP, 14); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.BYTE, thrift.STRING, len(p.MapInt8String)); err != nil {
		return err
	}
	for k, v := range p.MapInt8String {

		if err := oprot.WriteByte(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 14 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 14 end error: ", p), err)
}

func (p *InnerBase) writeField15(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapInt16String", thrift.MAP, 15); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.I16, thrift.STRING, len(p.MapInt16String)); err != nil {
		return err
	}
	for k, v := range p.MapInt16String {

		if err := oprot.WriteI16(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 15 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 15 end error: ", p), err)
}

func (p *InnerBase) writeField16(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapInt64String", thrift.MAP, 16); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.I64, thrift.STRING, len(p.MapInt64String)); err != nil {
		return err
	}
	for k, v := range p.MapInt64String {

		if err := oprot.WriteI64(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 16 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 16 end error: ", p), err)
}

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

func (p *InnerBase) writeField19(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapStringInnerBase", thrift.MAP, 19); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRUCT, len(p.MapStringInnerBase)); err != nil {
		return err
	}
	for k, v := range p.MapStringInnerBase {

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

		if err := v.Write(oprot); 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 19 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 19 end error: ", p), err)
}

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

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

func (p *InnerBase) DeepEqual(ano *InnerBase) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Bool) {
		return false
	}
	if !p.Field2DeepEqual(ano.Byte) {
		return false
	}
	if !p.Field3DeepEqual(ano.Int16) {
		return false
	}
	if !p.Field4DeepEqual(ano.Int32) {
		return false
	}
	if !p.Field5DeepEqual(ano.Int64) {
		return false
	}
	if !p.Field6DeepEqual(ano.Double) {
		return false
	}
	if !p.Field7DeepEqual(ano.String_) {
		return false
	}
	if !p.Field8DeepEqual(ano.ListInt32) {
		return false
	}
	if !p.Field9DeepEqual(ano.MapStringString) {
		return false
	}
	if !p.Field10DeepEqual(ano.SetInt32_) {
		return false
	}
	if !p.Field11DeepEqual(ano.Foo) {
		return false
	}
	if !p.Field12DeepEqual(ano.MapInt32String) {
		return false
	}
	if !p.Field13DeepEqual(ano.Binary) {
		return false
	}
	if !p.Field14DeepEqual(ano.MapInt8String) {
		return false
	}
	if !p.Field15DeepEqual(ano.MapInt16String) {
		return false
	}
	if !p.Field16DeepEqual(ano.MapInt64String) {
		return false
	}
	if !p.Field18DeepEqual(ano.ListInnerBase) {
		return false
	}
	if !p.Field19DeepEqual(ano.MapStringInnerBase) {
		return false
	}
	if !p.Field20DeepEqual(ano.InnerQuery) {
		return false
	}
	if !p.Field255DeepEqual(ano.Base) {
		return false
	}
	return true
}

func (p *InnerBase) Field1DeepEqual(src bool) bool {

	if p.Bool != src {
		return false
	}
	return true
}
func (p *InnerBase) Field2DeepEqual(src int8) bool {

	if p.Byte != src {
		return false
	}
	return true
}
func (p *InnerBase) Field3DeepEqual(src int16) bool {

	if p.Int16 != src {
		return false
	}
	return true
}
func (p *InnerBase) Field4DeepEqual(src int32) bool {

	if p.Int32 != src {
		return false
	}
	return true
}
func (p *InnerBase) Field5DeepEqual(src int64) bool {

	if p.Int64 != src {
		return false
	}
	return true
}
func (p *InnerBase) Field6DeepEqual(src float64) bool {

	if p.Double != src {
		return false
	}
	return true
}
func (p *InnerBase) Field7DeepEqual(src string) bool {

	if strings.Compare(p.String_, src) != 0 {
		return false
	}
	return true
}
func (p *InnerBase) Field8DeepEqual(src []int32) bool {

	if len(p.ListInt32) != len(src) {
		return false
	}
	for i, v := range p.ListInt32 {
		_src := src[i]
		if v != _src {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field9DeepEqual(src map[string]string) bool {

	if len(p.MapStringString) != len(src) {
		return false
	}
	for k, v := range p.MapStringString {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field10DeepEqual(src []int32) bool {

	if len(p.SetInt32_) != len(src) {
		return false
	}
	for i, v := range p.SetInt32_ {
		_src := src[i]
		if v != _src {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field11DeepEqual(src FOO) bool {

	if p.Foo != src {
		return false
	}
	return true
}
func (p *InnerBase) Field12DeepEqual(src map[int32]string) bool {

	if len(p.MapInt32String) != len(src) {
		return false
	}
	for k, v := range p.MapInt32String {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field13DeepEqual(src []byte) bool {

	if bytes.Compare(p.Binary, src) != 0 {
		return false
	}
	return true
}
func (p *InnerBase) Field14DeepEqual(src map[int8]string) bool {

	if len(p.MapInt8String) != len(src) {
		return false
	}
	for k, v := range p.MapInt8String {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field15DeepEqual(src map[int16]string) bool {

	if len(p.MapInt16String) != len(src) {
		return false
	}
	for k, v := range p.MapInt16String {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field16DeepEqual(src map[int64]string) bool {

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

	if len(p.ListInnerBase) != len(src) {
		return false
	}
	for i, v := range p.ListInnerBase {
		_src := src[i]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field19DeepEqual(src map[string]*InnerBase) bool {

	if len(p.MapStringInnerBase) != len(src) {
		return false
	}
	for k, v := range p.MapStringInnerBase {
		_src := src[k]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}
func (p *InnerBase) Field20DeepEqual(src string) bool {

	if strings.Compare(p.InnerQuery, src) != 0 {
		return false
	}
	return true
}
func (p *InnerBase) Field255DeepEqual(src *base.Base) bool {

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

type ExampleReq struct {
	Msg       *string    `thrift:"Msg,1" json:"msg"`
	Cookie    *float64   `thrift:"Cookie,2" json:"Cookie,omitempty"`
	Path      string     `thrift:"Path,3,required" json:"Path"`
	Query     []string   `thrift:"Query,4" json:"Query,omitempty"`
	Header    *bool      `thrift:"Header,5" json:"Header,omitempty"`
	Code      int64      `thrift:"Code,6" json:"code_code"`
	InnerBase *InnerBase `thrift:"InnerBase,7" json:"InnerBase"`
	RawUri    string     `thrift:"RawUri,8" json:"RawUri"`
	Subfix    float64    `thrift:"Subfix,32767" json:"Subfix"`
	Base      *base.Base `thrift:"Base,255" json:"Base"`
}

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
}

var ExampleReq_Cookie_DEFAULT float64

func (p *ExampleReq) GetCookie() (v float64) {
	if !p.IsSetCookie() {
		return ExampleReq_Cookie_DEFAULT
	}
	return *p.Cookie
}

func (p *ExampleReq) GetPath() (v string) {
	return p.Path
}

var ExampleReq_Query_DEFAULT []string

func (p *ExampleReq) GetQuery() (v []string) {
	if !p.IsSetQuery() {
		return ExampleReq_Query_DEFAULT
	}
	return p.Query
}

var ExampleReq_Header_DEFAULT bool

func (p *ExampleReq) GetHeader() (v bool) {
	if !p.IsSetHeader() {
		return ExampleReq_Header_DEFAULT
	}
	return *p.Header
}

func (p *ExampleReq) GetCode() (v int64) {
	return p.Code
}

var ExampleReq_InnerBase_DEFAULT *InnerBase

func (p *ExampleReq) GetInnerBase() (v *InnerBase) {
	if !p.IsSetInnerBase() {
		return ExampleReq_InnerBase_DEFAULT
	}
	return p.InnerBase
}

func (p *ExampleReq) GetRawUri() (v string) {
	return p.RawUri
}

func (p *ExampleReq) GetSubfix() (v float64) {
	return p.Subfix
}

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) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleReq) SetCookie(val *float64) {
	p.Cookie = val
}
func (p *ExampleReq) SetPath(val string) {
	p.Path = val
}
func (p *ExampleReq) SetQuery(val []string) {
	p.Query = val
}
func (p *ExampleReq) SetHeader(val *bool) {
	p.Header = val
}
func (p *ExampleReq) SetCode(val int64) {
	p.Code = val
}
func (p *ExampleReq) SetInnerBase(val *InnerBase) {
	p.InnerBase = val
}
func (p *ExampleReq) SetRawUri(val string) {
	p.RawUri = val
}
func (p *ExampleReq) SetSubfix(val float64) {
	p.Subfix = val
}
func (p *ExampleReq) SetBase(val *base.Base) {
	p.Base = val
}

var fieldIDToName_ExampleReq = map[int16]string{
	1:     "Msg",
	2:     "Cookie",
	3:     "Path",
	4:     "Query",
	5:     "Header",
	6:     "Code",
	7:     "InnerBase",
	8:     "RawUri",
	32767: "Subfix",
	255:   "Base",
}

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

func (p *ExampleReq) IsSetCookie() bool {
	return p.Cookie != nil
}

func (p *ExampleReq) IsSetQuery() bool {
	return p.Query != nil
}

func (p *ExampleReq) IsSetHeader() bool {
	return p.Header != nil
}

func (p *ExampleReq) IsSetInnerBase() bool {
	return p.InnerBase != 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 issetPath 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.DOUBLE {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
				issetPath = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.BOOL {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 7:
			if fieldTypeId == thrift.STRUCT {
				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 32767:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField32767(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
				}
			} 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 !issetPath {
		fieldId = 3
		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) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Cookie = &v
	}
	return nil
}

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

func (p *ExampleReq) ReadField4(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.Query = 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.Query = append(p.Query, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExampleReq) ReadField7(iprot thrift.TProtocol) error {
	p.InnerBase = NewInnerBase()
	if err := p.InnerBase.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleReq) ReadField8(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.RawUri = v
	}
	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) ReadField255(iprot thrift.TProtocol) error {
	p.Base = base.NewBase()
	if err := p.Base.Read(iprot); err != nil {
		return err
	}
	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.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.writeField32767(oprot); err != nil {
			fieldId = 32767
			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 *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) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCookie() {
		if err = oprot.WriteFieldBegin("Cookie", thrift.DOUBLE, 2); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteDouble(*p.Cookie); 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 *ExampleReq) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Path", thrift.STRING, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Path); 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) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetQuery() {
		if err = oprot.WriteFieldBegin("Query", thrift.LIST, 4); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.Query)); err != nil {
			return err
		}
		for _, v := range p.Query {
			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 4 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err)
}

func (p *ExampleReq) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetHeader() {
		if err = oprot.WriteFieldBegin("Header", thrift.BOOL, 5); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteBool(*p.Header); 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 *ExampleReq) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Code", thrift.I64, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(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 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *ExampleReq) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerBase", thrift.STRUCT, 7); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InnerBase.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 7 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err)
}

func (p *ExampleReq) writeField8(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("RawUri", thrift.STRING, 8); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.RawUri); 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 *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) 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) 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.Field2DeepEqual(ano.Cookie) {
		return false
	}
	if !p.Field3DeepEqual(ano.Path) {
		return false
	}
	if !p.Field4DeepEqual(ano.Query) {
		return false
	}
	if !p.Field5DeepEqual(ano.Header) {
		return false
	}
	if !p.Field6DeepEqual(ano.Code) {
		return false
	}
	if !p.Field7DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field8DeepEqual(ano.RawUri) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	if !p.Field255DeepEqual(ano.Base) {
		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) Field2DeepEqual(src *float64) bool {

	if p.Cookie == src {
		return true
	} else if p.Cookie == nil || src == nil {
		return false
	}
	if *p.Cookie != *src {
		return false
	}
	return true
}
func (p *ExampleReq) Field3DeepEqual(src string) bool {

	if strings.Compare(p.Path, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleReq) Field4DeepEqual(src []string) bool {

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

	if p.Header == src {
		return true
	} else if p.Header == nil || src == nil {
		return false
	}
	if *p.Header != *src {
		return false
	}
	return true
}
func (p *ExampleReq) Field6DeepEqual(src int64) bool {

	if p.Code != src {
		return false
	}
	return true
}
func (p *ExampleReq) Field7DeepEqual(src *InnerBase) bool {

	if !p.InnerBase.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleReq) Field8DeepEqual(src string) bool {

	if strings.Compare(p.RawUri, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleReq) Field32767DeepEqual(src float64) bool {

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

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

type ExampleResp struct {
	Msg       string         `thrift:"Msg,1" json:"Msg"`
	Cookie    *float64       `thrift:"Cookie,2" json:"Cookie,omitempty"`
	Status    int32          `thrift:"Status,3,required" json:"Status"`
	Header    *bool          `thrift:"Header,4" json:"Header,omitempty"`
	Code      int64          `thrift:"Code,6" json:"code_code"`
	Subfix    float64        `thrift:"Subfix,32767" json:"Subfix"`
	InnerBase *InnerBase     `thrift:"InnerBase,7" json:"InnerBase"`
	BaseResp  *base.BaseResp `thrift:"BaseResp,255" json:"BaseResp"`
}

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

func (p *ExampleResp) GetMsg() (v string) {
	return p.Msg
}

var ExampleResp_Cookie_DEFAULT float64

func (p *ExampleResp) GetCookie() (v float64) {
	if !p.IsSetCookie() {
		return ExampleResp_Cookie_DEFAULT
	}
	return *p.Cookie
}

func (p *ExampleResp) GetStatus() (v int32) {
	return p.Status
}

var ExampleResp_Header_DEFAULT bool

func (p *ExampleResp) GetHeader() (v bool) {
	if !p.IsSetHeader() {
		return ExampleResp_Header_DEFAULT
	}
	return *p.Header
}

func (p *ExampleResp) GetCode() (v int64) {
	return p.Code
}

func (p *ExampleResp) GetSubfix() (v float64) {
	return p.Subfix
}

var ExampleResp_InnerBase_DEFAULT *InnerBase

func (p *ExampleResp) GetInnerBase() (v *InnerBase) {
	if !p.IsSetInnerBase() {
		return ExampleResp_InnerBase_DEFAULT
	}
	return p.InnerBase
}

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) SetCookie(val *float64) {
	p.Cookie = val
}
func (p *ExampleResp) SetStatus(val int32) {
	p.Status = val
}
func (p *ExampleResp) SetHeader(val *bool) {
	p.Header = val
}
func (p *ExampleResp) SetCode(val int64) {
	p.Code = val
}
func (p *ExampleResp) SetSubfix(val float64) {
	p.Subfix = val
}
func (p *ExampleResp) SetInnerBase(val *InnerBase) {
	p.InnerBase = val
}
func (p *ExampleResp) SetBaseResp(val *base.BaseResp) {
	p.BaseResp = val
}

var fieldIDToName_ExampleResp = map[int16]string{
	1:     "Msg",
	2:     "Cookie",
	3:     "Status",
	4:     "Header",
	6:     "Code",
	32767: "Subfix",
	7:     "InnerBase",
	255:   "BaseResp",
}

func (p *ExampleResp) IsSetCookie() bool {
	return p.Cookie != nil
}

func (p *ExampleResp) IsSetHeader() bool {
	return p.Header != nil
}

func (p *ExampleResp) IsSetInnerBase() bool {
	return p.InnerBase != 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 issetStatus 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.DOUBLE {
				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
				}
				issetStatus = true
			} 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 6:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} 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
				}
			}
		case 7:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField7(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
				}
			} 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 !issetStatus {
		fieldId = 3
		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.ReadDouble(); err != nil {
		return err
	} else {
		p.Cookie = &v
	}
	return nil
}

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

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

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

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

func (p *ExampleResp) ReadField7(iprot thrift.TProtocol) error {
	p.InnerBase = NewInnerBase()
	if err := p.InnerBase.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleResp) ReadField255(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.writeField3(oprot); err != nil {
			fieldId = 3
			goto WriteFieldError
		}
		if err = p.writeField4(oprot); err != nil {
			fieldId = 4
			goto WriteFieldError
		}
		if err = p.writeField6(oprot); err != nil {
			fieldId = 6
			goto WriteFieldError
		}
		if err = p.writeField32767(oprot); err != nil {
			fieldId = 32767
			goto WriteFieldError
		}
		if err = p.writeField7(oprot); err != nil {
			fieldId = 7
			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 *ExampleResp) 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 *ExampleResp) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCookie() {
		if err = oprot.WriteFieldBegin("Cookie", thrift.DOUBLE, 2); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteDouble(*p.Cookie); 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) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Status", thrift.I32, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Status); 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 *ExampleResp) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetHeader() {
		if err = oprot.WriteFieldBegin("Header", thrift.BOOL, 4); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteBool(*p.Header); 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 *ExampleResp) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Code", thrift.I64, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(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 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *ExampleResp) 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 *ExampleResp) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerBase", thrift.STRUCT, 7); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InnerBase.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 7 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err)
}

func (p *ExampleResp) writeField255(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); 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 255 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 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.Cookie) {
		return false
	}
	if !p.Field3DeepEqual(ano.Status) {
		return false
	}
	if !p.Field4DeepEqual(ano.Header) {
		return false
	}
	if !p.Field6DeepEqual(ano.Code) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	if !p.Field7DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field255DeepEqual(ano.BaseResp) {
		return false
	}
	return true
}

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

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

	if p.Cookie == src {
		return true
	} else if p.Cookie == nil || src == nil {
		return false
	}
	if *p.Cookie != *src {
		return false
	}
	return true
}
func (p *ExampleResp) Field3DeepEqual(src int32) bool {

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

	if p.Header == src {
		return true
	} else if p.Header == nil || src == nil {
		return false
	}
	if *p.Header != *src {
		return false
	}
	return true
}
func (p *ExampleResp) Field6DeepEqual(src int64) bool {

	if p.Code != src {
		return false
	}
	return true
}
func (p *ExampleResp) Field32767DeepEqual(src float64) bool {

	if p.Subfix != src {
		return false
	}
	return true
}
func (p *ExampleResp) Field7DeepEqual(src *InnerBase) bool {

	if !p.InnerBase.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleResp) Field255DeepEqual(src *base.BaseResp) bool {

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

type ExampleError struct {
	MapInnerBaseInnerBase map[*InnerBase]*InnerBase `thrift:"MapInnerBaseInnerBase,1" json:"MapInnerBaseInnerBase"`
	Base64                []byte                    `thrift:"Base64,2" json:"Base64"`
	Query                 string                    `thrift:"Query,3,required" json:"Query"`
	Header                string                    `thrift:"Header,4" json:"Header"`
	Q2                    int32                     `thrift:"Q2,5" json:"Q2"`
}

func NewExampleError() *ExampleError {
	return &ExampleError{}
}

func (p *ExampleError) GetMapInnerBaseInnerBase() (v map[*InnerBase]*InnerBase) {
	return p.MapInnerBaseInnerBase
}

func (p *ExampleError) GetBase64() (v []byte) {
	return p.Base64
}

func (p *ExampleError) GetQuery() (v string) {
	return p.Query
}

func (p *ExampleError) GetHeader() (v string) {
	return p.Header
}

func (p *ExampleError) GetQ2() (v int32) {
	return p.Q2
}
func (p *ExampleError) SetMapInnerBaseInnerBase(val map[*InnerBase]*InnerBase) {
	p.MapInnerBaseInnerBase = val
}
func (p *ExampleError) SetBase64(val []byte) {
	p.Base64 = val
}
func (p *ExampleError) SetQuery(val string) {
	p.Query = val
}
func (p *ExampleError) SetHeader(val string) {
	p.Header = val
}
func (p *ExampleError) SetQ2(val int32) {
	p.Q2 = val
}

var fieldIDToName_ExampleError = map[int16]string{
	1: "MapInnerBaseInnerBase",
	2: "Base64",
	3: "Query",
	4: "Header",
	5: "Q2",
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetQuery 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.MAP {
				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
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
				issetQuery = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	if !issetQuery {
		fieldId = 3
		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_ExampleError[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_ExampleError[fieldId]))
}

func (p *ExampleError) ReadField1(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapInnerBaseInnerBase = make(map[*InnerBase]*InnerBase, size)
	for i := 0; i < size; i++ {
		_key := NewInnerBase()
		if err := _key.Read(iprot); err != nil {
			return err
		}
		_val := NewInnerBase()
		if err := _val.Read(iprot); err != nil {
			return err
		}

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

func (p *ExampleError) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return err
	} else {
		p.Base64 = []byte(v)
	}
	return nil
}

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

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

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

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

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

func (p *ExampleError) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapInnerBaseInnerBase", thrift.MAP, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.STRUCT, thrift.STRUCT, len(p.MapInnerBaseInnerBase)); err != nil {
		return err
	}
	for k, v := range p.MapInnerBaseInnerBase {

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

		if err := v.Write(oprot); 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 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *ExampleError) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Base64", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteBinary([]byte(p.Base64)); 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 *ExampleError) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Query", thrift.STRING, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Query); 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 *ExampleError) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Header", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Header); 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 *ExampleError) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Q2", thrift.I32, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Q2); 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 *ExampleError) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleError(%+v)", *p)
}

func (p *ExampleError) DeepEqual(ano *ExampleError) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.MapInnerBaseInnerBase) {
		return false
	}
	if !p.Field2DeepEqual(ano.Base64) {
		return false
	}
	if !p.Field3DeepEqual(ano.Query) {
		return false
	}
	if !p.Field4DeepEqual(ano.Header) {
		return false
	}
	if !p.Field5DeepEqual(ano.Q2) {
		return false
	}
	return true
}

func (p *ExampleError) Field1DeepEqual(src map[*InnerBase]*InnerBase) bool {

	if len(p.MapInnerBaseInnerBase) != len(src) {
		return false
	}
	for k, v := range p.MapInnerBaseInnerBase {
		_src := src[k]
		if !v.DeepEqual(_src) {
			return false
		}
	}
	return true
}
func (p *ExampleError) Field2DeepEqual(src []byte) bool {

	if bytes.Compare(p.Base64, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleError) Field3DeepEqual(src string) bool {

	if strings.Compare(p.Query, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleError) Field4DeepEqual(src string) bool {

	if strings.Compare(p.Header, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleError) Field5DeepEqual(src int32) bool {

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

type ExampleErrorResp struct {
	Int64 int64  `thrift:"Int64,2" json:"Int64"`
	Xjson string `thrift:"Xjson,4" json:"Xjson"`
}

func NewExampleErrorResp() *ExampleErrorResp {
	return &ExampleErrorResp{}
}

func (p *ExampleErrorResp) GetInt64() (v int64) {
	return p.Int64
}

func (p *ExampleErrorResp) GetXjson() (v string) {
	return p.Xjson
}
func (p *ExampleErrorResp) SetInt64(val int64) {
	p.Int64 = val
}
func (p *ExampleErrorResp) SetXjson(val string) {
	p.Xjson = val
}

var fieldIDToName_ExampleErrorResp = map[int16]string{
	2: "Int64",
	4: "Xjson",
}

func (p *ExampleErrorResp) 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 2:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField4(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_ExampleErrorResp[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 *ExampleErrorResp) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.Int64 = v
	}
	return nil
}

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

func (p *ExampleErrorResp) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleErrorResp"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}
		if err = p.writeField4(oprot); err != nil {
			fieldId = 4
			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 *ExampleErrorResp) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int64", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.Int64); 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 *ExampleErrorResp) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Xjson", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Xjson); 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 *ExampleErrorResp) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleErrorResp(%+v)", *p)
}

func (p *ExampleErrorResp) DeepEqual(ano *ExampleErrorResp) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field2DeepEqual(ano.Int64) {
		return false
	}
	if !p.Field4DeepEqual(ano.Xjson) {
		return false
	}
	return true
}

func (p *ExampleErrorResp) Field2DeepEqual(src int64) bool {

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

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

type ExampleInt2Float struct {
	Int32   int32   `thrift:"Int32,1" json:"Int32"`
	Float64 float64 `thrift:"Float64,2" json:"Float64"`
	String_ string  `thrift:"String,3" json:"中文"`
	Int64   int64   `thrift:"Int64,4" json:"Int64"`
	Subfix  float64 `thrift:"Subfix,32767" json:"Subfix"`
}

func NewExampleInt2Float() *ExampleInt2Float {
	return &ExampleInt2Float{}
}

func (p *ExampleInt2Float) GetInt32() (v int32) {
	return p.Int32
}

func (p *ExampleInt2Float) GetFloat64() (v float64) {
	return p.Float64
}

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

func (p *ExampleInt2Float) GetInt64() (v int64) {
	return p.Int64
}

func (p *ExampleInt2Float) GetSubfix() (v float64) {
	return p.Subfix
}
func (p *ExampleInt2Float) SetInt32(val int32) {
	p.Int32 = val
}
func (p *ExampleInt2Float) SetFloat64(val float64) {
	p.Float64 = val
}
func (p *ExampleInt2Float) SetString(val string) {
	p.String_ = val
}
func (p *ExampleInt2Float) SetInt64(val int64) {
	p.Int64 = val
}
func (p *ExampleInt2Float) SetSubfix(val float64) {
	p.Subfix = val
}

var fieldIDToName_ExampleInt2Float = map[int16]string{
	1:     "Int32",
	2:     "Float64",
	3:     "String",
	4:     "Int64",
	32767: "Subfix",
}

func (p *ExampleInt2Float) 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 2:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} 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
	}

	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_ExampleInt2Float[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 *ExampleInt2Float) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.Int32 = v
	}
	return nil
}

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

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

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

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

func (p *ExampleInt2Float) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleInt2Float"); 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.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 *ExampleInt2Float) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int32", thrift.I32, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Int32); 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 *ExampleInt2Float) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Float64", thrift.DOUBLE, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Float64); 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 *ExampleInt2Float) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("String", thrift.STRING, 3); 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 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

func (p *ExampleInt2Float) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Int64", thrift.I64, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.Int64); 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 *ExampleInt2Float) 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 *ExampleInt2Float) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleInt2Float(%+v)", *p)
}

func (p *ExampleInt2Float) DeepEqual(ano *ExampleInt2Float) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Int32) {
		return false
	}
	if !p.Field2DeepEqual(ano.Float64) {
		return false
	}
	if !p.Field3DeepEqual(ano.String_) {
		return false
	}
	if !p.Field4DeepEqual(ano.Int64) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	return true
}

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

	if p.Int32 != src {
		return false
	}
	return true
}
func (p *ExampleInt2Float) Field2DeepEqual(src float64) bool {

	if p.Float64 != src {
		return false
	}
	return true
}
func (p *ExampleInt2Float) Field3DeepEqual(src string) bool {

	if strings.Compare(p.String_, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleInt2Float) Field4DeepEqual(src int64) bool {

	if p.Int64 != src {
		return false
	}
	return true
}
func (p *ExampleInt2Float) Field32767DeepEqual(src float64) bool {

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

type JSONObject struct {
	A string `thrift:"A,1" json:"a"`
	B int8   `thrift:"B,2" json:"b"`
}

func NewJSONObject() *JSONObject {
	return &JSONObject{}
}

func (p *JSONObject) GetA() (v string) {
	return p.A
}

func (p *JSONObject) GetB() (v int8) {
	return p.B
}
func (p *JSONObject) SetA(val string) {
	p.A = val
}
func (p *JSONObject) SetB(val int8) {
	p.B = val
}

var fieldIDToName_JSONObject = map[int16]string{
	1: "A",
	2: "B",
}

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

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

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

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

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

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

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

type ExampleJSONString struct {
	Query   *JSONObject      `thrift:"Query,1" json:"Query"`
	Query2  []string         `thrift:"Query2,2,required" json:"Query2"`
	Header  *JSONObject      `thrift:"Header,3,required" json:"Header"`
	Header2 map[int32]string `thrift:"Header2,4,required" json:"Header2"`
	Cookie  *JSONObject      `thrift:"Cookie,5" json:"Cookie"`
	Cookie2 []int32          `thrift:"Cookie2,6,required" json:"Cookie2"`
}

func NewExampleJSONString() *ExampleJSONString {
	return &ExampleJSONString{}
}

var ExampleJSONString_Query_DEFAULT *JSONObject

func (p *ExampleJSONString) GetQuery() (v *JSONObject) {
	if !p.IsSetQuery() {
		return ExampleJSONString_Query_DEFAULT
	}
	return p.Query
}

func (p *ExampleJSONString) GetQuery2() (v []string) {
	return p.Query2
}

var ExampleJSONString_Header_DEFAULT *JSONObject

func (p *ExampleJSONString) GetHeader() (v *JSONObject) {
	if !p.IsSetHeader() {
		return ExampleJSONString_Header_DEFAULT
	}
	return p.Header
}

func (p *ExampleJSONString) GetHeader2() (v map[int32]string) {
	return p.Header2
}

var ExampleJSONString_Cookie_DEFAULT *JSONObject

func (p *ExampleJSONString) GetCookie() (v *JSONObject) {
	if !p.IsSetCookie() {
		return ExampleJSONString_Cookie_DEFAULT
	}
	return p.Cookie
}

func (p *ExampleJSONString) GetCookie2() (v []int32) {
	return p.Cookie2
}
func (p *ExampleJSONString) SetQuery(val *JSONObject) {
	p.Query = val
}
func (p *ExampleJSONString) SetQuery2(val []string) {
	p.Query2 = val
}
func (p *ExampleJSONString) SetHeader(val *JSONObject) {
	p.Header = val
}
func (p *ExampleJSONString) SetHeader2(val map[int32]string) {
	p.Header2 = val
}
func (p *ExampleJSONString) SetCookie(val *JSONObject) {
	p.Cookie = val
}
func (p *ExampleJSONString) SetCookie2(val []int32) {
	p.Cookie2 = val
}

var fieldIDToName_ExampleJSONString = map[int16]string{
	1: "Query",
	2: "Query2",
	3: "Header",
	4: "Header2",
	5: "Cookie",
	6: "Cookie2",
}

func (p *ExampleJSONString) IsSetQuery() bool {
	return p.Query != nil
}

func (p *ExampleJSONString) IsSetHeader() bool {
	return p.Header != nil
}

func (p *ExampleJSONString) IsSetCookie() bool {
	return p.Cookie != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetQuery2 bool = false
	var issetHeader bool = false
	var issetHeader2 bool = false
	var issetCookie2 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.STRUCT {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
				issetQuery2 = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
				issetHeader = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
				issetHeader2 = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.SET {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
				issetCookie2 = 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 !issetQuery2 {
		fieldId = 2
		goto RequiredFieldNotSetError
	}

	if !issetHeader {
		fieldId = 3
		goto RequiredFieldNotSetError
	}

	if !issetHeader2 {
		fieldId = 4
		goto RequiredFieldNotSetError
	}

	if !issetCookie2 {
		fieldId = 6
		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_ExampleJSONString[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_ExampleJSONString[fieldId]))
}

func (p *ExampleJSONString) ReadField1(iprot thrift.TProtocol) error {
	p.Query = NewJSONObject()
	if err := p.Query.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleJSONString) ReadField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.Query2 = 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.Query2 = append(p.Query2, _elem)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return err
	}
	return nil
}

func (p *ExampleJSONString) ReadField3(iprot thrift.TProtocol) error {
	p.Header = NewJSONObject()
	if err := p.Header.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

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

func (p *ExampleJSONString) ReadField5(iprot thrift.TProtocol) error {
	p.Cookie = NewJSONObject()
	if err := p.Cookie.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *ExampleJSONString) ReadField6(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return err
	}
	p.Cookie2 = make([]int32, 0, size)
	for i := 0; i < size; i++ {
		var _elem int32
		if v, err := iprot.ReadI32(); err != nil {
			return err
		} else {
			_elem = v
		}

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

func (p *ExampleJSONString) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleJSONString"); 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 = 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 *ExampleJSONString) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Query", thrift.STRUCT, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Query.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 *ExampleJSONString) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Query2", thrift.LIST, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRING, len(p.Query2)); err != nil {
		return err
	}
	for _, v := range p.Query2 {
		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 *ExampleJSONString) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Header", thrift.STRUCT, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Header.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 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

func (p *ExampleJSONString) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Header2", thrift.MAP, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.I32, thrift.STRING, len(p.Header2)); err != nil {
		return err
	}
	for k, v := range p.Header2 {

		if err := oprot.WriteI32(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 4 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err)
}

func (p *ExampleJSONString) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Cookie", thrift.STRUCT, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Cookie.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 5 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err)
}

func (p *ExampleJSONString) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Cookie2", thrift.SET, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteSetBegin(thrift.I32, len(p.Cookie2)); err != nil {
		return err
	}
	for i := 0; i < len(p.Cookie2); i++ {
		for j := i + 1; j < len(p.Cookie2); j++ {
			if func(tgt, src int32) bool {
				if tgt != src {
					return false
				}
				return true
			}(p.Cookie2[i], p.Cookie2[j]) {
				return thrift.PrependError("", fmt.Errorf("%T error writing set field: slice is not unique", p.Cookie2[i]))
			}
		}
	}
	for _, v := range p.Cookie2 {
		if err := oprot.WriteI32(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 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

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

func (p *ExampleJSONString) DeepEqual(ano *ExampleJSONString) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Query) {
		return false
	}
	if !p.Field2DeepEqual(ano.Query2) {
		return false
	}
	if !p.Field3DeepEqual(ano.Header) {
		return false
	}
	if !p.Field4DeepEqual(ano.Header2) {
		return false
	}
	if !p.Field5DeepEqual(ano.Cookie) {
		return false
	}
	if !p.Field6DeepEqual(ano.Cookie2) {
		return false
	}
	return true
}

func (p *ExampleJSONString) Field1DeepEqual(src *JSONObject) bool {

	if !p.Query.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleJSONString) Field2DeepEqual(src []string) bool {

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

	if !p.Header.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleJSONString) Field4DeepEqual(src map[int32]string) bool {

	if len(p.Header2) != len(src) {
		return false
	}
	for k, v := range p.Header2 {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *ExampleJSONString) Field5DeepEqual(src *JSONObject) bool {

	if !p.Cookie.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleJSONString) Field6DeepEqual(src []int32) bool {

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

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

func NewExamplePartial() *ExamplePartial {
	return &ExamplePartial{}
}

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

var fieldIDToName_ExamplePartial = map[int16]string{
	1: "Msg",
}

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

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

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

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

type ExamplePartial2 struct {
	Msg       string            `thrift:"Msg,1" json:"msg"`
	Cookie    *float64          `thrift:"Cookie,2" json:"Cookie,omitempty"`
	Status    int32             `thrift:"Status,3,required" json:"Status"`
	Header    *bool             `thrift:"Header,4" json:"Header,omitempty"`
	Code      int64             `thrift:"Code,6" json:"code_code"`
	Subfix    float64           `thrift:"Subfix,32767" json:"Subfix"`
	InnerBase *InnerBasePartial `thrift:"InnerBase,7" json:"InnerBase"`
	BaseResp  *base.BaseResp    `thrift:"BaseResp,255" json:"BaseResp"`
}

func NewExamplePartial2() *ExamplePartial2 {
	return &ExamplePartial2{}
}

func (p *ExamplePartial2) GetMsg() (v string) {
	return p.Msg
}

var ExamplePartial2_Cookie_DEFAULT float64

func (p *ExamplePartial2) GetCookie() (v float64) {
	if !p.IsSetCookie() {
		return ExamplePartial2_Cookie_DEFAULT
	}
	return *p.Cookie
}

func (p *ExamplePartial2) GetStatus() (v int32) {
	return p.Status
}

var ExamplePartial2_Header_DEFAULT bool

func (p *ExamplePartial2) GetHeader() (v bool) {
	if !p.IsSetHeader() {
		return ExamplePartial2_Header_DEFAULT
	}
	return *p.Header
}

func (p *ExamplePartial2) GetCode() (v int64) {
	return p.Code
}

func (p *ExamplePartial2) GetSubfix() (v float64) {
	return p.Subfix
}

var ExamplePartial2_InnerBase_DEFAULT *InnerBasePartial

func (p *ExamplePartial2) GetInnerBase() (v *InnerBasePartial) {
	if !p.IsSetInnerBase() {
		return ExamplePartial2_InnerBase_DEFAULT
	}
	return p.InnerBase
}

var ExamplePartial2_BaseResp_DEFAULT *base.BaseResp

func (p *ExamplePartial2) GetBaseResp() (v *base.BaseResp) {
	if !p.IsSetBaseResp() {
		return ExamplePartial2_BaseResp_DEFAULT
	}
	return p.BaseResp
}
func (p *ExamplePartial2) SetMsg(val string) {
	p.Msg = val
}
func (p *ExamplePartial2) SetCookie(val *float64) {
	p.Cookie = val
}
func (p *ExamplePartial2) SetStatus(val int32) {
	p.Status = val
}
func (p *ExamplePartial2) SetHeader(val *bool) {
	p.Header = val
}
func (p *ExamplePartial2) SetCode(val int64) {
	p.Code = val
}
func (p *ExamplePartial2) SetSubfix(val float64) {
	p.Subfix = val
}
func (p *ExamplePartial2) SetInnerBase(val *InnerBasePartial) {
	p.InnerBase = val
}
func (p *ExamplePartial2) SetBaseResp(val *base.BaseResp) {
	p.BaseResp = val
}

var fieldIDToName_ExamplePartial2 = map[int16]string{
	1:     "Msg",
	2:     "Cookie",
	3:     "Status",
	4:     "Header",
	6:     "Code",
	32767: "Subfix",
	7:     "InnerBase",
	255:   "BaseResp",
}

func (p *ExamplePartial2) IsSetCookie() bool {
	return p.Cookie != nil
}

func (p *ExamplePartial2) IsSetHeader() bool {
	return p.Header != nil
}

func (p *ExamplePartial2) IsSetInnerBase() bool {
	return p.InnerBase != nil
}

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

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetStatus 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.DOUBLE {
				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
				}
				issetStatus = true
			} 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 6:
			if fieldTypeId == thrift.I64 {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} 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
				}
			}
		case 7:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField7(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
				}
			} 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 !issetStatus {
		fieldId = 3
		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_ExamplePartial2[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_ExamplePartial2[fieldId]))
}

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

func (p *ExamplePartial2) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Cookie = &v
	}
	return nil
}

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

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

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

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

func (p *ExamplePartial2) ReadField7(iprot thrift.TProtocol) error {
	p.InnerBase = NewInnerBasePartial()
	if err := p.InnerBase.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

func (p *ExamplePartial2) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExamplePartial2"); 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.writeField6(oprot); err != nil {
			fieldId = 6
			goto WriteFieldError
		}
		if err = p.writeField32767(oprot); err != nil {
			fieldId = 32767
			goto WriteFieldError
		}
		if err = p.writeField7(oprot); err != nil {
			fieldId = 7
			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 *ExamplePartial2) 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 *ExamplePartial2) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetCookie() {
		if err = oprot.WriteFieldBegin("Cookie", thrift.DOUBLE, 2); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteDouble(*p.Cookie); 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 *ExamplePartial2) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Status", thrift.I32, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Status); 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 *ExamplePartial2) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetHeader() {
		if err = oprot.WriteFieldBegin("Header", thrift.BOOL, 4); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteBool(*p.Header); 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 *ExamplePartial2) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Code", thrift.I64, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(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 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *ExamplePartial2) 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 *ExamplePartial2) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerBase", thrift.STRUCT, 7); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InnerBase.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 7 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err)
}

func (p *ExamplePartial2) writeField255(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); 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 255 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err)
}

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

func (p *ExamplePartial2) DeepEqual(ano *ExamplePartial2) 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.Cookie) {
		return false
	}
	if !p.Field3DeepEqual(ano.Status) {
		return false
	}
	if !p.Field4DeepEqual(ano.Header) {
		return false
	}
	if !p.Field6DeepEqual(ano.Code) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	if !p.Field7DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field255DeepEqual(ano.BaseResp) {
		return false
	}
	return true
}

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

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field2DeepEqual(src *float64) bool {

	if p.Cookie == src {
		return true
	} else if p.Cookie == nil || src == nil {
		return false
	}
	if *p.Cookie != *src {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field3DeepEqual(src int32) bool {

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

	if p.Header == src {
		return true
	} else if p.Header == nil || src == nil {
		return false
	}
	if *p.Header != *src {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field6DeepEqual(src int64) bool {

	if p.Code != src {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field32767DeepEqual(src float64) bool {

	if p.Subfix != src {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field7DeepEqual(src *InnerBasePartial) bool {

	if !p.InnerBase.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExamplePartial2) Field255DeepEqual(src *base.BaseResp) bool {

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

type InnerBasePartial struct {
	Bool bool       `thrift:"Bool,1" json:"Bool"`
	Base *base.Base `thrift:"Base,255" json:"Base"`
}

func NewInnerBasePartial() *InnerBasePartial {
	return &InnerBasePartial{}
}

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

var InnerBasePartial_Base_DEFAULT *base.Base

func (p *InnerBasePartial) GetBase() (v *base.Base) {
	if !p.IsSetBase() {
		return InnerBasePartial_Base_DEFAULT
	}
	return p.Base
}
func (p *InnerBasePartial) SetBool(val bool) {
	p.Bool = val
}
func (p *InnerBasePartial) SetBase(val *base.Base) {
	p.Base = val
}

var fieldIDToName_InnerBasePartial = map[int16]string{
	1:   "Bool",
	255: "Base",
}

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

func (p *InnerBasePartial) 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.BOOL {
				if err = p.ReadField1(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
				}
			} 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_InnerBasePartial[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 *InnerBasePartial) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return err
	} else {
		p.Bool = v
	}
	return nil
}

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

func (p *InnerBasePartial) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("InnerBasePartial"); 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 *InnerBasePartial) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Bool", thrift.BOOL, 1); 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 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

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

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

func (p *InnerBasePartial) Field1DeepEqual(src bool) bool {

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

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

type ExampleFallback struct {
	Msg     string `thrift:"Msg,2" json:"Msg"`
	Heeader string `thrift:"Heeader,3" json:"Heeader"`
}

func NewExampleFallback() *ExampleFallback {
	return &ExampleFallback{}
}

func (p *ExampleFallback) GetMsg() (v string) {
	return p.Msg
}

func (p *ExampleFallback) GetHeeader() (v string) {
	return p.Heeader
}
func (p *ExampleFallback) SetMsg(val string) {
	p.Msg = val
}
func (p *ExampleFallback) SetHeeader(val string) {
	p.Heeader = val
}

var fieldIDToName_ExampleFallback = map[int16]string{
	2: "Msg",
	3: "Heeader",
}

func (p *ExampleFallback) 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 2:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleFallback[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 *ExampleFallback) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = v
	}
	return nil
}

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

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

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

func (p *ExampleFallback) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Msg", thrift.STRING, 2); 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 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *ExampleFallback) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Heeader", thrift.STRING, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Heeader); 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 *ExampleFallback) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleFallback(%+v)", *p)
}

func (p *ExampleFallback) DeepEqual(ano *ExampleFallback) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field2DeepEqual(ano.Msg) {
		return false
	}
	if !p.Field3DeepEqual(ano.Heeader) {
		return false
	}
	return true
}

func (p *ExampleFallback) Field2DeepEqual(src string) bool {

	if strings.Compare(p.Msg, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleFallback) Field3DeepEqual(src string) bool {

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

type InnerCode struct {
	C1 int64        `thrift:"C1,1" json:"C1"`
	C2 int16        `thrift:"C2,2" json:"code"`
	C3 []*InnerCode `thrift:"C3,3" json:"C3"`
}

func NewInnerCode() *InnerCode {
	return &InnerCode{}
}

func (p *InnerCode) GetC1() (v int64) {
	return p.C1
}

func (p *InnerCode) GetC2() (v int16) {
	return p.C2
}

func (p *InnerCode) GetC3() (v []*InnerCode) {
	return p.C3
}
func (p *InnerCode) SetC1(val int64) {
	p.C1 = val
}
func (p *InnerCode) SetC2(val int16) {
	p.C2 = val
}
func (p *InnerCode) SetC3(val []*InnerCode) {
	p.C3 = val
}

var fieldIDToName_InnerCode = map[int16]string{
	1: "C1",
	2: "C2",
	3: "C3",
}

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InnerCode[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 *InnerCode) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.C1 = v
	}
	return nil
}

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

func (p *InnerCode) ReadField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.C3 = make([]*InnerCode, 0, size)
	for i := 0; i < size; i++ {
		_elem := NewInnerCode()
		if err := _elem.Read(iprot); err != nil {
			return err
		}

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

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

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

func (p *InnerCode) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("C1", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.C1); 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 *InnerCode) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("C2", thrift.I16, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI16(p.C2); 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 *InnerCode) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("C3", thrift.LIST, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.C3)); err != nil {
		return err
	}
	for _, v := range p.C3 {
		if err := v.Write(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

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

func (p *InnerCode) DeepEqual(ano *InnerCode) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.C1) {
		return false
	}
	if !p.Field2DeepEqual(ano.C2) {
		return false
	}
	if !p.Field3DeepEqual(ano.C3) {
		return false
	}
	return true
}

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

	if p.C1 != src {
		return false
	}
	return true
}
func (p *InnerCode) Field2DeepEqual(src int16) bool {

	if p.C2 != src {
		return false
	}
	return true
}
func (p *InnerCode) Field3DeepEqual(src []*InnerCode) bool {

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

type ExampleApiBody struct {
	Code      int64      `thrift:"Code,1" json:"Code"`
	Code2     int16      `thrift:"Code2,2" json:"code"`
	InnerCode *InnerCode `thrift:"InnerCode,3" json:"InnerCode"`
}

func NewExampleApiBody() *ExampleApiBody {
	return &ExampleApiBody{}
}

func (p *ExampleApiBody) GetCode() (v int64) {
	return p.Code
}

func (p *ExampleApiBody) GetCode2() (v int16) {
	return p.Code2
}

var ExampleApiBody_InnerCode_DEFAULT *InnerCode

func (p *ExampleApiBody) GetInnerCode() (v *InnerCode) {
	if !p.IsSetInnerCode() {
		return ExampleApiBody_InnerCode_DEFAULT
	}
	return p.InnerCode
}
func (p *ExampleApiBody) SetCode(val int64) {
	p.Code = val
}
func (p *ExampleApiBody) SetCode2(val int16) {
	p.Code2 = val
}
func (p *ExampleApiBody) SetInnerCode(val *InnerCode) {
	p.InnerCode = val
}

var fieldIDToName_ExampleApiBody = map[int16]string{
	1: "Code",
	2: "Code2",
	3: "InnerCode",
}

func (p *ExampleApiBody) IsSetInnerCode() bool {
	return p.InnerCode != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleApiBody[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 *ExampleApiBody) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.Code = v
	}
	return nil
}

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

func (p *ExampleApiBody) ReadField3(iprot thrift.TProtocol) error {
	p.InnerCode = NewInnerCode()
	if err := p.InnerCode.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExampleApiBody) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Code", thrift.I64, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(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 *ExampleApiBody) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Code2", thrift.I16, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI16(p.Code2); 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 *ExampleApiBody) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerCode", thrift.STRUCT, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InnerCode.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 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

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

func (p *ExampleApiBody) DeepEqual(ano *ExampleApiBody) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Code) {
		return false
	}
	if !p.Field2DeepEqual(ano.Code2) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerCode) {
		return false
	}
	return true
}

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

	if p.Code != src {
		return false
	}
	return true
}
func (p *ExampleApiBody) Field2DeepEqual(src int16) bool {

	if p.Code2 != src {
		return false
	}
	return true
}
func (p *ExampleApiBody) Field3DeepEqual(src *InnerCode) bool {

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

type InnerJSON struct {
	A         string  `thrift:"A,1" json:"a"`
	B         int64   `thrift:"B,2" json:"b"`
	InnerForm float64 `thrift:"inner_form,3" json:"inner_form"`
}

func NewInnerJSON() *InnerJSON {
	return &InnerJSON{}
}

func (p *InnerJSON) GetA() (v string) {
	return p.A
}

func (p *InnerJSON) GetB() (v int64) {
	return p.B
}

func (p *InnerJSON) GetInnerForm() (v float64) {
	return p.InnerForm
}
func (p *InnerJSON) SetA(val string) {
	p.A = val
}
func (p *InnerJSON) SetB(val int64) {
	p.B = val
}
func (p *InnerJSON) SetInnerForm(val float64) {
	p.InnerForm = val
}

var fieldIDToName_InnerJSON = map[int16]string{
	1: "A",
	2: "B",
	3: "inner_form",
}

func (p *InnerJSON) 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.I64 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_InnerJSON[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 *InnerJSON) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.A = v
	}
	return nil
}

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

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

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

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

func (p *InnerJSON) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("A", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.A); 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 *InnerJSON) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("B", thrift.I64, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI64(p.B); 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 *InnerJSON) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("inner_form", thrift.DOUBLE, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.InnerForm); 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 *InnerJSON) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InnerJSON(%+v)", *p)
}

func (p *InnerJSON) DeepEqual(ano *InnerJSON) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.A) {
		return false
	}
	if !p.Field2DeepEqual(ano.B) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerForm) {
		return false
	}
	return true
}

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

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

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

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

type ExamplePostForm struct {
	Query string     `thrift:"Query,1" json:"Query"`
	Form  string     `thrift:"Form,2" json:"Form"`
	JSON  *InnerJSON `thrift:"JSON,3" json:"JSON"`
}

func NewExamplePostForm() *ExamplePostForm {
	return &ExamplePostForm{}
}

func (p *ExamplePostForm) GetQuery() (v string) {
	return p.Query
}

func (p *ExamplePostForm) GetForm() (v string) {
	return p.Form
}

var ExamplePostForm_JSON_DEFAULT *InnerJSON

func (p *ExamplePostForm) GetJSON() (v *InnerJSON) {
	if !p.IsSetJSON() {
		return ExamplePostForm_JSON_DEFAULT
	}
	return p.JSON
}
func (p *ExamplePostForm) SetQuery(val string) {
	p.Query = val
}
func (p *ExamplePostForm) SetForm(val string) {
	p.Form = val
}
func (p *ExamplePostForm) SetJSON(val *InnerJSON) {
	p.JSON = val
}

var fieldIDToName_ExamplePostForm = map[int16]string{
	1: "Query",
	2: "Form",
	3: "JSON",
}

func (p *ExamplePostForm) IsSetJSON() bool {
	return p.JSON != nil
}

func (p *ExamplePostForm) 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.STRING {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExamplePostForm[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 *ExamplePostForm) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Query = v
	}
	return nil
}

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

func (p *ExamplePostForm) ReadField3(iprot thrift.TProtocol) error {
	p.JSON = NewInnerJSON()
	if err := p.JSON.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExamplePostForm) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Query", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Query); 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 *ExamplePostForm) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Form", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Form); 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 *ExamplePostForm) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("JSON", thrift.STRUCT, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.JSON.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 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

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

func (p *ExamplePostForm) DeepEqual(ano *ExamplePostForm) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Query) {
		return false
	}
	if !p.Field2DeepEqual(ano.Form) {
		return false
	}
	if !p.Field3DeepEqual(ano.JSON) {
		return false
	}
	return true
}

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

	if strings.Compare(p.Query, src) != 0 {
		return false
	}
	return true
}
func (p *ExamplePostForm) Field2DeepEqual(src string) bool {

	if strings.Compare(p.Form, src) != 0 {
		return false
	}
	return true
}
func (p *ExamplePostForm) Field3DeepEqual(src *InnerJSON) bool {

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

type InnerStruct struct {
	InnerJSON string `thrift:"InnerJSON,1" json:"inner_json"`
	Must      string `thrift:"Must,2,required" json:"Must"`
}

func NewInnerStruct() *InnerStruct {
	return &InnerStruct{}
}

func (p *InnerStruct) GetInnerJSON() (v string) {
	return p.InnerJSON
}

func (p *InnerStruct) GetMust() (v string) {
	return p.Must
}
func (p *InnerStruct) SetInnerJSON(val string) {
	p.InnerJSON = val
}
func (p *InnerStruct) SetMust(val string) {
	p.Must = val
}

var fieldIDToName_InnerStruct = map[int16]string{
	1: "InnerJSON",
	2: "Must",
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetMust 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
				}
				issetMust = 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 !issetMust {
		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_InnerStruct[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_InnerStruct[fieldId]))
}

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

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

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

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

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

	if strings.Compare(p.InnerJSON, src) != 0 {
		return false
	}
	return true
}
func (p *InnerStruct) Field2DeepEqual(src string) bool {

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

type ExampleDynamicStruct struct {
	Query       string       `thrift:"Query,1,required" json:"Query"`
	JSON        string       `thrift:"JSON,2" json:"json"`
	InnerStruct *InnerStruct `thrift:"InnerStruct,3" json:"inner_struct"`
}

func NewExampleDynamicStruct() *ExampleDynamicStruct {
	return &ExampleDynamicStruct{}
}

func (p *ExampleDynamicStruct) GetQuery() (v string) {
	return p.Query
}

func (p *ExampleDynamicStruct) GetJSON() (v string) {
	return p.JSON
}

var ExampleDynamicStruct_InnerStruct_DEFAULT *InnerStruct

func (p *ExampleDynamicStruct) GetInnerStruct() (v *InnerStruct) {
	if !p.IsSetInnerStruct() {
		return ExampleDynamicStruct_InnerStruct_DEFAULT
	}
	return p.InnerStruct
}
func (p *ExampleDynamicStruct) SetQuery(val string) {
	p.Query = val
}
func (p *ExampleDynamicStruct) SetJSON(val string) {
	p.JSON = val
}
func (p *ExampleDynamicStruct) SetInnerStruct(val *InnerStruct) {
	p.InnerStruct = val
}

var fieldIDToName_ExampleDynamicStruct = map[int16]string{
	1: "Query",
	2: "JSON",
	3: "InnerStruct",
}

func (p *ExampleDynamicStruct) IsSetInnerStruct() bool {
	return p.InnerStruct != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetQuery 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
				}
				issetQuery = true
			} 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
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	if !issetQuery {
		fieldId = 1
		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_ExampleDynamicStruct[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_ExampleDynamicStruct[fieldId]))
}

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

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

func (p *ExampleDynamicStruct) ReadField3(iprot thrift.TProtocol) error {
	p.InnerStruct = NewInnerStruct()
	if err := p.InnerStruct.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExampleDynamicStruct) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Query", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Query); 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 *ExampleDynamicStruct) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("JSON", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.JSON); 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 *ExampleDynamicStruct) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("InnerStruct", thrift.STRUCT, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.InnerStruct.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 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

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

func (p *ExampleDynamicStruct) DeepEqual(ano *ExampleDynamicStruct) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Query) {
		return false
	}
	if !p.Field2DeepEqual(ano.JSON) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerStruct) {
		return false
	}
	return true
}

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

	if strings.Compare(p.Query, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleDynamicStruct) Field2DeepEqual(src string) bool {

	if strings.Compare(p.JSON, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleDynamicStruct) Field3DeepEqual(src *InnerStruct) bool {

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

type ExampleBase64Binary struct {
	Binary  []byte `thrift:"Binary,1" json:"Binary"`
	Binary2 []byte `thrift:"Binary2,2" json:"Binary2"`
}

func NewExampleBase64Binary() *ExampleBase64Binary {
	return &ExampleBase64Binary{}
}

func (p *ExampleBase64Binary) GetBinary() (v []byte) {
	return p.Binary
}

func (p *ExampleBase64Binary) GetBinary2() (v []byte) {
	return p.Binary2
}
func (p *ExampleBase64Binary) SetBinary(val []byte) {
	p.Binary = val
}
func (p *ExampleBase64Binary) SetBinary2(val []byte) {
	p.Binary2 = val
}

var fieldIDToName_ExampleBase64Binary = map[int16]string{
	1: "Binary",
	2: "Binary2",
}

func (p *ExampleBase64Binary) 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.STRING {
				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_ExampleBase64Binary[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 *ExampleBase64Binary) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return err
	} else {
		p.Binary = []byte(v)
	}
	return nil
}

func (p *ExampleBase64Binary) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return err
	} else {
		p.Binary2 = []byte(v)
	}
	return nil
}

func (p *ExampleBase64Binary) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleBase64Binary"); 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 *ExampleBase64Binary) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Binary", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteBinary([]byte(p.Binary)); 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 *ExampleBase64Binary) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Binary2", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteBinary([]byte(p.Binary2)); 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 *ExampleBase64Binary) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleBase64Binary(%+v)", *p)
}

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

func (p *ExampleBase64Binary) Field1DeepEqual(src []byte) bool {

	if bytes.Compare(p.Binary, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleBase64Binary) Field2DeepEqual(src []byte) bool {

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

type ExampleDefaultValue struct {
	A string  `thrift:"A,1" json:"A"`
	B int32   `thrift:"B,2" json:"B"`
	C float64 `thrift:"C,3" json:"C"`
	D string  `thrift:"D,4" json:"D"`
}

func NewExampleDefaultValue() *ExampleDefaultValue {
	return &ExampleDefaultValue{

		A: "hello",
		B: int32(ref.FOO_A),
		C: 1.2,
		D: ref.ConstString,
	}
}

func (p *ExampleDefaultValue) GetA() (v string) {
	return p.A
}

func (p *ExampleDefaultValue) GetB() (v int32) {
	return p.B
}

func (p *ExampleDefaultValue) GetC() (v float64) {
	return p.C
}

func (p *ExampleDefaultValue) GetD() (v string) {
	return p.D
}
func (p *ExampleDefaultValue) SetA(val string) {
	p.A = val
}
func (p *ExampleDefaultValue) SetB(val int32) {
	p.B = val
}
func (p *ExampleDefaultValue) SetC(val float64) {
	p.C = val
}
func (p *ExampleDefaultValue) SetD(val string) {
	p.D = val
}

var fieldIDToName_ExampleDefaultValue = map[int16]string{
	1: "A",
	2: "B",
	3: "C",
	4: "D",
}

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.STRING {
				if err = p.ReadField4(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.A = v
	}
	return nil
}

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

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

func (p *ExampleDefaultValue) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.D = 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 = 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("A", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.A); 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("B", thrift.I32, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.B); 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("C", thrift.DOUBLE, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.C); 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("D", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.D); 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) 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.A) {
		return false
	}
	if !p.Field2DeepEqual(ano.B) {
		return false
	}
	if !p.Field3DeepEqual(ano.C) {
		return false
	}
	if !p.Field4DeepEqual(ano.D) {
		return false
	}
	return true
}

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

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

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

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

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

type ExampleOptionalDefaultValue struct {
	A string  `thrift:"A,1" json:"A,omitempty"`
	B int32   `thrift:"B,2,required" json:"B"`
	C float64 `thrift:"C,3" json:"C,omitempty"`
	D string  `thrift:"D,4,required" json:"D"`
	E *string `thrift:"E,5" json:"E,omitempty"`
	F *string `thrift:"F,6" json:"F,omitempty"`
}

func NewExampleOptionalDefaultValue() *ExampleOptionalDefaultValue {
	return &ExampleOptionalDefaultValue{

		A: "hello",
		B: int32(ref.FOO_A),
		C: 1.2,
		D: ref.ConstString,
	}
}

var ExampleOptionalDefaultValue_A_DEFAULT string = "hello"

func (p *ExampleOptionalDefaultValue) GetA() (v string) {
	if !p.IsSetA() {
		return ExampleOptionalDefaultValue_A_DEFAULT
	}
	return p.A
}

func (p *ExampleOptionalDefaultValue) GetB() (v int32) {
	return p.B
}

var ExampleOptionalDefaultValue_C_DEFAULT float64 = 1.2

func (p *ExampleOptionalDefaultValue) GetC() (v float64) {
	if !p.IsSetC() {
		return ExampleOptionalDefaultValue_C_DEFAULT
	}
	return p.C
}

func (p *ExampleOptionalDefaultValue) GetD() (v string) {
	return p.D
}

var ExampleOptionalDefaultValue_E_DEFAULT string

func (p *ExampleOptionalDefaultValue) GetE() (v string) {
	if !p.IsSetE() {
		return ExampleOptionalDefaultValue_E_DEFAULT
	}
	return *p.E
}

var ExampleOptionalDefaultValue_F_DEFAULT string

func (p *ExampleOptionalDefaultValue) GetF() (v string) {
	if !p.IsSetF() {
		return ExampleOptionalDefaultValue_F_DEFAULT
	}
	return *p.F
}
func (p *ExampleOptionalDefaultValue) SetA(val string) {
	p.A = val
}
func (p *ExampleOptionalDefaultValue) SetB(val int32) {
	p.B = val
}
func (p *ExampleOptionalDefaultValue) SetC(val float64) {
	p.C = val
}
func (p *ExampleOptionalDefaultValue) SetD(val string) {
	p.D = val
}
func (p *ExampleOptionalDefaultValue) SetE(val *string) {
	p.E = val
}
func (p *ExampleOptionalDefaultValue) SetF(val *string) {
	p.F = val
}

var fieldIDToName_ExampleOptionalDefaultValue = map[int16]string{
	1: "A",
	2: "B",
	3: "C",
	4: "D",
	5: "E",
	6: "F",
}

func (p *ExampleOptionalDefaultValue) IsSetA() bool {
	return p.A != ExampleOptionalDefaultValue_A_DEFAULT
}

func (p *ExampleOptionalDefaultValue) IsSetC() bool {
	return p.C != ExampleOptionalDefaultValue_C_DEFAULT
}

func (p *ExampleOptionalDefaultValue) IsSetE() bool {
	return p.E != nil
}

func (p *ExampleOptionalDefaultValue) IsSetF() bool {
	return p.F != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16
	var issetB bool = false
	var issetD 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.I32 {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
				issetB = true
			} 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.STRING {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
				issetD = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField6(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 !issetB {
		fieldId = 2
		goto RequiredFieldNotSetError
	}

	if !issetD {
		fieldId = 4
		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_ExampleOptionalDefaultValue[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_ExampleOptionalDefaultValue[fieldId]))
}

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

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

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

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

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

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

func (p *ExampleOptionalDefaultValue) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleOptionalDefaultValue"); 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 = 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 *ExampleOptionalDefaultValue) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetA() {
		if err = oprot.WriteFieldBegin("A", thrift.STRING, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(p.A); 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 *ExampleOptionalDefaultValue) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("B", thrift.I32, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.B); 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 *ExampleOptionalDefaultValue) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetC() {
		if err = oprot.WriteFieldBegin("C", thrift.DOUBLE, 3); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteDouble(p.C); 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 *ExampleOptionalDefaultValue) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("D", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.D); 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 *ExampleOptionalDefaultValue) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetE() {
		if err = oprot.WriteFieldBegin("E", thrift.STRING, 5); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.E); 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 *ExampleOptionalDefaultValue) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetF() {
		if err = oprot.WriteFieldBegin("F", thrift.STRING, 6); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.F); 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 *ExampleOptionalDefaultValue) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExampleOptionalDefaultValue(%+v)", *p)
}

func (p *ExampleOptionalDefaultValue) DeepEqual(ano *ExampleOptionalDefaultValue) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.A) {
		return false
	}
	if !p.Field2DeepEqual(ano.B) {
		return false
	}
	if !p.Field3DeepEqual(ano.C) {
		return false
	}
	if !p.Field4DeepEqual(ano.D) {
		return false
	}
	if !p.Field5DeepEqual(ano.E) {
		return false
	}
	if !p.Field6DeepEqual(ano.F) {
		return false
	}
	return true
}

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

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

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

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

	if strings.Compare(p.D, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleOptionalDefaultValue) Field5DeepEqual(src *string) bool {

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

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

type ExampleNoBodyStruct struct {
	NoBodyStruct *NoBodyStruct `thrift:"NoBodyStruct,1" json:"NoBodyStruct"`
}

func NewExampleNoBodyStruct() *ExampleNoBodyStruct {
	return &ExampleNoBodyStruct{}
}

var ExampleNoBodyStruct_NoBodyStruct_DEFAULT *NoBodyStruct

func (p *ExampleNoBodyStruct) GetNoBodyStruct() (v *NoBodyStruct) {
	if !p.IsSetNoBodyStruct() {
		return ExampleNoBodyStruct_NoBodyStruct_DEFAULT
	}
	return p.NoBodyStruct
}
func (p *ExampleNoBodyStruct) SetNoBodyStruct(val *NoBodyStruct) {
	p.NoBodyStruct = val
}

var fieldIDToName_ExampleNoBodyStruct = map[int16]string{
	1: "NoBodyStruct",
}

func (p *ExampleNoBodyStruct) IsSetNoBodyStruct() bool {
	return p.NoBodyStruct != nil
}

func (p *ExampleNoBodyStruct) 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_ExampleNoBodyStruct[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 *ExampleNoBodyStruct) ReadField1(iprot thrift.TProtocol) error {
	p.NoBodyStruct = NewNoBodyStruct()
	if err := p.NoBodyStruct.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExampleNoBodyStruct) Field1DeepEqual(src *NoBodyStruct) bool {

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

type NoBodyStruct struct {
	A *int32 `thrift:"A,1" json:"A,omitempty"`
	B *int32 `thrift:"B,2" json:"B,omitempty"`
	C int32  `thrift:"C,3" json:"C,omitempty"`
}

func NewNoBodyStruct() *NoBodyStruct {
	return &NoBodyStruct{

		C: 1,
	}
}

var NoBodyStruct_A_DEFAULT int32

func (p *NoBodyStruct) GetA() (v int32) {
	if !p.IsSetA() {
		return NoBodyStruct_A_DEFAULT
	}
	return *p.A
}

var NoBodyStruct_B_DEFAULT int32

func (p *NoBodyStruct) GetB() (v int32) {
	if !p.IsSetB() {
		return NoBodyStruct_B_DEFAULT
	}
	return *p.B
}

var NoBodyStruct_C_DEFAULT int32 = 1

func (p *NoBodyStruct) GetC() (v int32) {
	if !p.IsSetC() {
		return NoBodyStruct_C_DEFAULT
	}
	return p.C
}
func (p *NoBodyStruct) SetA(val *int32) {
	p.A = val
}
func (p *NoBodyStruct) SetB(val *int32) {
	p.B = val
}
func (p *NoBodyStruct) SetC(val int32) {
	p.C = val
}

var fieldIDToName_NoBodyStruct = map[int16]string{
	1: "A",
	2: "B",
	3: "C",
}

func (p *NoBodyStruct) IsSetA() bool {
	return p.A != nil
}

func (p *NoBodyStruct) IsSetB() bool {
	return p.B != nil
}

func (p *NoBodyStruct) IsSetC() bool {
	return p.C != NoBodyStruct_C_DEFAULT
}

func (p *NoBodyStruct) 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 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.I32 {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_NoBodyStruct[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 *NoBodyStruct) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.A = &v
	}
	return nil
}

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

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

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

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

func (p *NoBodyStruct) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetA() {
		if err = oprot.WriteFieldBegin("A", thrift.I32, 1); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteI32(*p.A); 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 *NoBodyStruct) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetB() {
		if err = oprot.WriteFieldBegin("B", thrift.I32, 2); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteI32(*p.B); 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 *NoBodyStruct) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetC() {
		if err = oprot.WriteFieldBegin("C", thrift.I32, 3); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteI32(p.C); 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 *NoBodyStruct) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("NoBodyStruct(%+v)", *p)
}

func (p *NoBodyStruct) DeepEqual(ano *NoBodyStruct) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.A) {
		return false
	}
	if !p.Field2DeepEqual(ano.B) {
		return false
	}
	if !p.Field3DeepEqual(ano.C) {
		return false
	}
	return true
}

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

	if p.A == src {
		return true
	} else if p.A == nil || src == nil {
		return false
	}
	if *p.A != *src {
		return false
	}
	return true
}
func (p *NoBodyStruct) Field2DeepEqual(src *int32) bool {

	if p.B == src {
		return true
	} else if p.B == nil || src == nil {
		return false
	}
	if *p.B != *src {
		return false
	}
	return true
}
func (p *NoBodyStruct) Field3DeepEqual(src int32) bool {

	if p.C != 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 {
	ExampleMethod(ctx context.Context, req *ExampleReq) (r *ExampleResp, err error)

	ErrorMethod(ctx context.Context, req *ExampleError) (r *ExampleErrorResp, err error)

	Int2FloatMethod(ctx context.Context, req *ExampleInt2Float) (r *ExampleInt2Float, err error)

	JSONStringMethod(ctx context.Context, req *ExampleJSONString) (r *ExampleJSONString, err error)

	PartialMethod(ctx context.Context, req *ExamplePartial2) (r *ExamplePartial, err error)

	FallbackMethod(ctx context.Context, req *ExampleFallback) (r *ExampleFallback, err error)

	ApiBodyMethod(ctx context.Context, req *ExampleApiBody) (r *ExampleApiBody, err error)

	PostFormMethod(ctx context.Context, req *ExamplePostForm) (r *ExamplePostForm, err error)

	DynamicStructMethod(ctx context.Context, req *ExampleDynamicStruct) (r *ExampleDynamicStruct, err error)

	Base64BinaryMethod(ctx context.Context, req *ExampleBase64Binary) (r *ExampleBase64Binary, err error)

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

	OptionalDefaultValueMethod(ctx context.Context, req *ExampleOptionalDefaultValue) (r *ExampleOptionalDefaultValue, err error)

	NoBodyStructMethod(ctx context.Context, req *ExampleNoBodyStruct) (r *ExampleNoBodyStruct, err error)

	String(ctx context.Context, req string) (r string, err error)

	I64(ctx context.Context, req int64) (r int64, 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) 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) ErrorMethod(ctx context.Context, req *ExampleError) (r *ExampleErrorResp, err error) {
	var _args ExampleServiceErrorMethodArgs
	_args.Req = req
	var _result ExampleServiceErrorMethodResult
	if err = p.Client_().Call(ctx, "ErrorMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

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

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

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

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

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

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

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

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

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

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

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

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

func (p *ExampleServiceClient) I64(ctx context.Context, req int64) (r int64, err error) {
	var _args ExampleServiceI64Args
	_args.Req = req
	var _result ExampleServiceI64Result
	if err = p.Client_().Call(ctx, "I64", &_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("ExampleMethod", &exampleServiceProcessorExampleMethod{handler: handler})
	self.AddToProcessorMap("ErrorMethod", &exampleServiceProcessorErrorMethod{handler: handler})
	self.AddToProcessorMap("Int2FloatMethod", &exampleServiceProcessorInt2FloatMethod{handler: handler})
	self.AddToProcessorMap("JSONStringMethod", &exampleServiceProcessorJSONStringMethod{handler: handler})
	self.AddToProcessorMap("PartialMethod", &exampleServiceProcessorPartialMethod{handler: handler})
	self.AddToProcessorMap("FallbackMethod", &exampleServiceProcessorFallbackMethod{handler: handler})
	self.AddToProcessorMap("ApiBodyMethod", &exampleServiceProcessorApiBodyMethod{handler: handler})
	self.AddToProcessorMap("PostFormMethod", &exampleServiceProcessorPostFormMethod{handler: handler})
	self.AddToProcessorMap("DynamicStructMethod", &exampleServiceProcessorDynamicStructMethod{handler: handler})
	self.AddToProcessorMap("Base64BinaryMethod", &exampleServiceProcessorBase64BinaryMethod{handler: handler})
	self.AddToProcessorMap("DefaultValueMethod", &exampleServiceProcessorDefaultValueMethod{handler: handler})
	self.AddToProcessorMap("OptionalDefaultValueMethod", &exampleServiceProcessorOptionalDefaultValueMethod{handler: handler})
	self.AddToProcessorMap("NoBodyStructMethod", &exampleServiceProcessorNoBodyStructMethod{handler: handler})
	self.AddToProcessorMap("String", &exampleServiceProcessorString{handler: handler})
	self.AddToProcessorMap("I64", &exampleServiceProcessorI64{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 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 exampleServiceProcessorErrorMethod struct {
	handler ExampleService
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func NewExampleServiceErrorMethodArgs() *ExampleServiceErrorMethodArgs {
	return &ExampleServiceErrorMethodArgs{}
}

var ExampleServiceErrorMethodArgs_Req_DEFAULT *ExampleError

func (p *ExampleServiceErrorMethodArgs) GetReq() (v *ExampleError) {
	if !p.IsSetReq() {
		return ExampleServiceErrorMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceErrorMethodArgs) SetReq(val *ExampleError) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceErrorMethodResult struct {
	Success *ExampleErrorResp `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceErrorMethodResult() *ExampleServiceErrorMethodResult {
	return &ExampleServiceErrorMethodResult{}
}

var ExampleServiceErrorMethodResult_Success_DEFAULT *ExampleErrorResp

func (p *ExampleServiceErrorMethodResult) GetSuccess() (v *ExampleErrorResp) {
	if !p.IsSetSuccess() {
		return ExampleServiceErrorMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceErrorMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleErrorResp)
}

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

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

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

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

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

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

type ExampleServiceInt2FloatMethodArgs struct {
	Req *ExampleInt2Float `thrift:"req,1" json:"req"`
}

func NewExampleServiceInt2FloatMethodArgs() *ExampleServiceInt2FloatMethodArgs {
	return &ExampleServiceInt2FloatMethodArgs{}
}

var ExampleServiceInt2FloatMethodArgs_Req_DEFAULT *ExampleInt2Float

func (p *ExampleServiceInt2FloatMethodArgs) GetReq() (v *ExampleInt2Float) {
	if !p.IsSetReq() {
		return ExampleServiceInt2FloatMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceInt2FloatMethodArgs) SetReq(val *ExampleInt2Float) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceInt2FloatMethodResult struct {
	Success *ExampleInt2Float `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceInt2FloatMethodResult() *ExampleServiceInt2FloatMethodResult {
	return &ExampleServiceInt2FloatMethodResult{}
}

var ExampleServiceInt2FloatMethodResult_Success_DEFAULT *ExampleInt2Float

func (p *ExampleServiceInt2FloatMethodResult) GetSuccess() (v *ExampleInt2Float) {
	if !p.IsSetSuccess() {
		return ExampleServiceInt2FloatMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceInt2FloatMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleInt2Float)
}

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

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

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

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

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

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

type ExampleServiceJSONStringMethodArgs struct {
	Req *ExampleJSONString `thrift:"req,1" json:"req"`
}

func NewExampleServiceJSONStringMethodArgs() *ExampleServiceJSONStringMethodArgs {
	return &ExampleServiceJSONStringMethodArgs{}
}

var ExampleServiceJSONStringMethodArgs_Req_DEFAULT *ExampleJSONString

func (p *ExampleServiceJSONStringMethodArgs) GetReq() (v *ExampleJSONString) {
	if !p.IsSetReq() {
		return ExampleServiceJSONStringMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceJSONStringMethodArgs) SetReq(val *ExampleJSONString) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceJSONStringMethodResult struct {
	Success *ExampleJSONString `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceJSONStringMethodResult() *ExampleServiceJSONStringMethodResult {
	return &ExampleServiceJSONStringMethodResult{}
}

var ExampleServiceJSONStringMethodResult_Success_DEFAULT *ExampleJSONString

func (p *ExampleServiceJSONStringMethodResult) GetSuccess() (v *ExampleJSONString) {
	if !p.IsSetSuccess() {
		return ExampleServiceJSONStringMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceJSONStringMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleJSONString)
}

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

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

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

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

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

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

type ExampleServicePartialMethodArgs struct {
	Req *ExamplePartial2 `thrift:"req,1" json:"req"`
}

func NewExampleServicePartialMethodArgs() *ExampleServicePartialMethodArgs {
	return &ExampleServicePartialMethodArgs{}
}

var ExampleServicePartialMethodArgs_Req_DEFAULT *ExamplePartial2

func (p *ExampleServicePartialMethodArgs) GetReq() (v *ExamplePartial2) {
	if !p.IsSetReq() {
		return ExampleServicePartialMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServicePartialMethodArgs) SetReq(val *ExamplePartial2) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServicePartialMethodResult struct {
	Success *ExamplePartial `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServicePartialMethodResult() *ExampleServicePartialMethodResult {
	return &ExampleServicePartialMethodResult{}
}

var ExampleServicePartialMethodResult_Success_DEFAULT *ExamplePartial

func (p *ExampleServicePartialMethodResult) GetSuccess() (v *ExamplePartial) {
	if !p.IsSetSuccess() {
		return ExampleServicePartialMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServicePartialMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExamplePartial)
}

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

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

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

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

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

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

type ExampleServiceFallbackMethodArgs struct {
	Req *ExampleFallback `thrift:"req,1" json:"req"`
}

func NewExampleServiceFallbackMethodArgs() *ExampleServiceFallbackMethodArgs {
	return &ExampleServiceFallbackMethodArgs{}
}

var ExampleServiceFallbackMethodArgs_Req_DEFAULT *ExampleFallback

func (p *ExampleServiceFallbackMethodArgs) GetReq() (v *ExampleFallback) {
	if !p.IsSetReq() {
		return ExampleServiceFallbackMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceFallbackMethodArgs) SetReq(val *ExampleFallback) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceFallbackMethodResult struct {
	Success *ExampleFallback `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceFallbackMethodResult() *ExampleServiceFallbackMethodResult {
	return &ExampleServiceFallbackMethodResult{}
}

var ExampleServiceFallbackMethodResult_Success_DEFAULT *ExampleFallback

func (p *ExampleServiceFallbackMethodResult) GetSuccess() (v *ExampleFallback) {
	if !p.IsSetSuccess() {
		return ExampleServiceFallbackMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceFallbackMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleFallback)
}

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

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

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

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

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

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

type ExampleServiceApiBodyMethodArgs struct {
	Req *ExampleApiBody `thrift:"req,1" json:"req"`
}

func NewExampleServiceApiBodyMethodArgs() *ExampleServiceApiBodyMethodArgs {
	return &ExampleServiceApiBodyMethodArgs{}
}

var ExampleServiceApiBodyMethodArgs_Req_DEFAULT *ExampleApiBody

func (p *ExampleServiceApiBodyMethodArgs) GetReq() (v *ExampleApiBody) {
	if !p.IsSetReq() {
		return ExampleServiceApiBodyMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceApiBodyMethodArgs) SetReq(val *ExampleApiBody) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceApiBodyMethodResult struct {
	Success *ExampleApiBody `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceApiBodyMethodResult() *ExampleServiceApiBodyMethodResult {
	return &ExampleServiceApiBodyMethodResult{}
}

var ExampleServiceApiBodyMethodResult_Success_DEFAULT *ExampleApiBody

func (p *ExampleServiceApiBodyMethodResult) GetSuccess() (v *ExampleApiBody) {
	if !p.IsSetSuccess() {
		return ExampleServiceApiBodyMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceApiBodyMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleApiBody)
}

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

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

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

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

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

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

type ExampleServicePostFormMethodArgs struct {
	Req *ExamplePostForm `thrift:"req,1" json:"req"`
}

func NewExampleServicePostFormMethodArgs() *ExampleServicePostFormMethodArgs {
	return &ExampleServicePostFormMethodArgs{}
}

var ExampleServicePostFormMethodArgs_Req_DEFAULT *ExamplePostForm

func (p *ExampleServicePostFormMethodArgs) GetReq() (v *ExamplePostForm) {
	if !p.IsSetReq() {
		return ExampleServicePostFormMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServicePostFormMethodArgs) SetReq(val *ExamplePostForm) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServicePostFormMethodResult struct {
	Success *ExamplePostForm `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServicePostFormMethodResult() *ExampleServicePostFormMethodResult {
	return &ExampleServicePostFormMethodResult{}
}

var ExampleServicePostFormMethodResult_Success_DEFAULT *ExamplePostForm

func (p *ExampleServicePostFormMethodResult) GetSuccess() (v *ExamplePostForm) {
	if !p.IsSetSuccess() {
		return ExampleServicePostFormMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServicePostFormMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExamplePostForm)
}

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

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

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

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

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

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

type ExampleServiceDynamicStructMethodArgs struct {
	Req *ExampleDynamicStruct `thrift:"req,1" json:"req"`
}

func NewExampleServiceDynamicStructMethodArgs() *ExampleServiceDynamicStructMethodArgs {
	return &ExampleServiceDynamicStructMethodArgs{}
}

var ExampleServiceDynamicStructMethodArgs_Req_DEFAULT *ExampleDynamicStruct

func (p *ExampleServiceDynamicStructMethodArgs) GetReq() (v *ExampleDynamicStruct) {
	if !p.IsSetReq() {
		return ExampleServiceDynamicStructMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceDynamicStructMethodArgs) SetReq(val *ExampleDynamicStruct) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceDynamicStructMethodResult struct {
	Success *ExampleDynamicStruct `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceDynamicStructMethodResult() *ExampleServiceDynamicStructMethodResult {
	return &ExampleServiceDynamicStructMethodResult{}
}

var ExampleServiceDynamicStructMethodResult_Success_DEFAULT *ExampleDynamicStruct

func (p *ExampleServiceDynamicStructMethodResult) GetSuccess() (v *ExampleDynamicStruct) {
	if !p.IsSetSuccess() {
		return ExampleServiceDynamicStructMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceDynamicStructMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleDynamicStruct)
}

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

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

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

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

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

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

type ExampleServiceBase64BinaryMethodArgs struct {
	Req *ExampleBase64Binary `thrift:"req,1" json:"req"`
}

func NewExampleServiceBase64BinaryMethodArgs() *ExampleServiceBase64BinaryMethodArgs {
	return &ExampleServiceBase64BinaryMethodArgs{}
}

var ExampleServiceBase64BinaryMethodArgs_Req_DEFAULT *ExampleBase64Binary

func (p *ExampleServiceBase64BinaryMethodArgs) GetReq() (v *ExampleBase64Binary) {
	if !p.IsSetReq() {
		return ExampleServiceBase64BinaryMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceBase64BinaryMethodArgs) SetReq(val *ExampleBase64Binary) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceBase64BinaryMethodResult struct {
	Success *ExampleBase64Binary `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceBase64BinaryMethodResult() *ExampleServiceBase64BinaryMethodResult {
	return &ExampleServiceBase64BinaryMethodResult{}
}

var ExampleServiceBase64BinaryMethodResult_Success_DEFAULT *ExampleBase64Binary

func (p *ExampleServiceBase64BinaryMethodResult) GetSuccess() (v *ExampleBase64Binary) {
	if !p.IsSetSuccess() {
		return ExampleServiceBase64BinaryMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceBase64BinaryMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleBase64Binary)
}

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

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

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

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

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

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

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

func NewExampleServiceDefaultValueMethodArgs() *ExampleServiceDefaultValueMethodArgs {
	return &ExampleServiceDefaultValueMethodArgs{}
}

var ExampleServiceDefaultValueMethodArgs_Req_DEFAULT *ExampleDefaultValue

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

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

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

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

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

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

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

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

func NewExampleServiceDefaultValueMethodResult() *ExampleServiceDefaultValueMethodResult {
	return &ExampleServiceDefaultValueMethodResult{}
}

var ExampleServiceDefaultValueMethodResult_Success_DEFAULT *ExampleDefaultValue

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

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

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

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

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

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

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

type ExampleServiceOptionalDefaultValueMethodArgs struct {
	Req *ExampleOptionalDefaultValue `thrift:"req,1" json:"req"`
}

func NewExampleServiceOptionalDefaultValueMethodArgs() *ExampleServiceOptionalDefaultValueMethodArgs {
	return &ExampleServiceOptionalDefaultValueMethodArgs{}
}

var ExampleServiceOptionalDefaultValueMethodArgs_Req_DEFAULT *ExampleOptionalDefaultValue

func (p *ExampleServiceOptionalDefaultValueMethodArgs) GetReq() (v *ExampleOptionalDefaultValue) {
	if !p.IsSetReq() {
		return ExampleServiceOptionalDefaultValueMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceOptionalDefaultValueMethodArgs) SetReq(val *ExampleOptionalDefaultValue) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceOptionalDefaultValueMethodResult struct {
	Success *ExampleOptionalDefaultValue `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceOptionalDefaultValueMethodResult() *ExampleServiceOptionalDefaultValueMethodResult {
	return &ExampleServiceOptionalDefaultValueMethodResult{}
}

var ExampleServiceOptionalDefaultValueMethodResult_Success_DEFAULT *ExampleOptionalDefaultValue

func (p *ExampleServiceOptionalDefaultValueMethodResult) GetSuccess() (v *ExampleOptionalDefaultValue) {
	if !p.IsSetSuccess() {
		return ExampleServiceOptionalDefaultValueMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceOptionalDefaultValueMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleOptionalDefaultValue)
}

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

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

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

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

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

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

type ExampleServiceNoBodyStructMethodArgs struct {
	Req *ExampleNoBodyStruct `thrift:"req,1" json:"req"`
}

func NewExampleServiceNoBodyStructMethodArgs() *ExampleServiceNoBodyStructMethodArgs {
	return &ExampleServiceNoBodyStructMethodArgs{}
}

var ExampleServiceNoBodyStructMethodArgs_Req_DEFAULT *ExampleNoBodyStruct

func (p *ExampleServiceNoBodyStructMethodArgs) GetReq() (v *ExampleNoBodyStruct) {
	if !p.IsSetReq() {
		return ExampleServiceNoBodyStructMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceNoBodyStructMethodArgs) SetReq(val *ExampleNoBodyStruct) {
	p.Req = val
}

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

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

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

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

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

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

type ExampleServiceNoBodyStructMethodResult struct {
	Success *ExampleNoBodyStruct `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceNoBodyStructMethodResult() *ExampleServiceNoBodyStructMethodResult {
	return &ExampleServiceNoBodyStructMethodResult{}
}

var ExampleServiceNoBodyStructMethodResult_Success_DEFAULT *ExampleNoBodyStruct

func (p *ExampleServiceNoBodyStructMethodResult) GetSuccess() (v *ExampleNoBodyStruct) {
	if !p.IsSetSuccess() {
		return ExampleServiceNoBodyStructMethodResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExampleServiceNoBodyStructMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*ExampleNoBodyStruct)
}

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

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

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

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

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

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

type ExampleServiceStringArgs struct {
	Req string `thrift:"req,1" json:"req"`
}

func NewExampleServiceStringArgs() *ExampleServiceStringArgs {
	return &ExampleServiceStringArgs{}
}

func (p *ExampleServiceStringArgs) GetReq() (v string) {
	return p.Req
}
func (p *ExampleServiceStringArgs) SetReq(val string) {
	p.Req = val
}

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

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

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

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

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

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

func NewExampleServiceStringResult() *ExampleServiceStringResult {
	return &ExampleServiceStringResult{}
}

var ExampleServiceStringResult_Success_DEFAULT string

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

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

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

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

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

func (p *ExampleServiceStringResult) DeepEqual(ano *ExampleServiceStringResult) 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 *ExampleServiceStringResult) 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 ExampleServiceI64Args struct {
	Req int64 `thrift:"req,1" json:"req"`
}

func NewExampleServiceI64Args() *ExampleServiceI64Args {
	return &ExampleServiceI64Args{}
}

func (p *ExampleServiceI64Args) GetReq() (v int64) {
	return p.Req
}
func (p *ExampleServiceI64Args) SetReq(val int64) {
	p.Req = val
}

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleServiceI64Args[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 *ExampleServiceI64Args) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return err
	} else {
		p.Req = v
	}
	return nil
}

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

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

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

type ExampleServiceI64Result struct {
	Success *int64 `thrift:"success,0" json:"success,omitempty"`
}

func NewExampleServiceI64Result() *ExampleServiceI64Result {
	return &ExampleServiceI64Result{}
}

var ExampleServiceI64Result_Success_DEFAULT int64

func (p *ExampleServiceI64Result) GetSuccess() (v int64) {
	if !p.IsSetSuccess() {
		return ExampleServiceI64Result_Success_DEFAULT
	}
	return *p.Success
}
func (p *ExampleServiceI64Result) SetSuccess(x interface{}) {
	p.Success = x.(*int64)
}

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

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

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

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

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

	if p.Success == src {
		return true
	} else if p.Success == nil || src == nil {
		return false
	}
	if *p.Success != *src {
		return false
	}
	return true
}