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

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

package example2

import (
	"bytes"
	"github.com/cloudwego/dynamicgo/testdata/kitex_gen/base"
	"context"
	"database/sql"
	"database/sql/driver"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
	"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"`
	MapDoubleString       map[float64]string        `thrift:"MapDoubleString,17" json:"MapDoubleString"`
	ListInnerBase         []*InnerBase              `thrift:"ListInnerBase,18" json:"ListInnerBase"`
	MapInnerBaseInnerBase map[*InnerBase]*InnerBase `thrift:"MapInnerBaseInnerBase,19" json:"MapInnerBaseInnerBase"`
	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) GetMapDoubleString() (v map[float64]string) {
	return p.MapDoubleString
}

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

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

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) SetMapDoubleString(val map[float64]string) {
	p.MapDoubleString = val
}
func (p *InnerBase) SetListInnerBase(val []*InnerBase) {
	p.ListInnerBase = val
}
func (p *InnerBase) SetMapInnerBaseInnerBase(val map[*InnerBase]*InnerBase) {
	p.MapInnerBaseInnerBase = 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",
	17:  "MapDoubleString",
	18:  "ListInnerBase",
	19:  "MapInnerBaseInnerBase",
	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 17:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField17(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 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) ReadField17(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapDoubleString = make(map[float64]string, size)
	for i := 0; i < size; i++ {
		var _key float64
		if v, err := iprot.ReadDouble(); err != nil {
			return err
		} else {
			_key = v
		}

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

		p.MapDoubleString[_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.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 *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.writeField17(oprot); err != nil {
			fieldId = 17
			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.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) writeField17(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapDoubleString", thrift.MAP, 17); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.DOUBLE, thrift.STRING, len(p.MapDoubleString)); err != nil {
		return err
	}
	for k, v := range p.MapDoubleString {

		if err := oprot.WriteDouble(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 17 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 17 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("MapInnerBaseInnerBase", thrift.MAP, 19); 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 19 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 19 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.Field17DeepEqual(ano.MapDoubleString) {
		return false
	}
	if !p.Field18DeepEqual(ano.ListInnerBase) {
		return false
	}
	if !p.Field19DeepEqual(ano.MapInnerBaseInnerBase) {
		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) Field17DeepEqual(src map[float64]string) bool {

	if len(p.MapDoubleString) != len(src) {
		return false
	}
	for k, v := range p.MapDoubleString {
		_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[*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 *InnerBase) Field255DeepEqual(src *base.Base) bool {

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

type InnerBasePartial struct {
	Bool                  bool                                    `thrift:"Bool,1" json:"Bool"`
	ListInt32             []int32                                 `thrift:"ListInt32,8" json:"ListInt32"`
	MapStringString       map[string]string                       `thrift:"MapStringString,9" json:"MapStringString"`
	MapDoubleString       map[float64]string                      `thrift:"MapDoubleString,17" json:"MapDoubleString"`
	ListInnerBase         []*InnerBasePartial                     `thrift:"ListInnerBase,18" json:"ListInnerBase"`
	MapInnerBaseInnerBase map[*InnerBasePartial]*InnerBasePartial `thrift:"MapInnerBaseInnerBase,19" json:"MapInnerBaseInnerBase"`
	MapStringString2      map[string]string                       `thrift:"MapStringString2,127" json:"MapStringString2"`
}

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

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

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

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

func (p *InnerBasePartial) GetMapDoubleString() (v map[float64]string) {
	return p.MapDoubleString
}

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

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

func (p *InnerBasePartial) GetMapStringString2() (v map[string]string) {
	return p.MapStringString2
}
func (p *InnerBasePartial) SetBool(val bool) {
	p.Bool = val
}
func (p *InnerBasePartial) SetListInt32(val []int32) {
	p.ListInt32 = val
}
func (p *InnerBasePartial) SetMapStringString(val map[string]string) {
	p.MapStringString = val
}
func (p *InnerBasePartial) SetMapDoubleString(val map[float64]string) {
	p.MapDoubleString = val
}
func (p *InnerBasePartial) SetListInnerBase(val []*InnerBasePartial) {
	p.ListInnerBase = val
}
func (p *InnerBasePartial) SetMapInnerBaseInnerBase(val map[*InnerBasePartial]*InnerBasePartial) {
	p.MapInnerBaseInnerBase = val
}
func (p *InnerBasePartial) SetMapStringString2(val map[string]string) {
	p.MapStringString2 = val
}

var fieldIDToName_InnerBasePartial = map[int16]string{
	1:   "Bool",
	8:   "ListInt32",
	9:   "MapStringString",
	17:  "MapDoubleString",
	18:  "ListInnerBase",
	19:  "MapInnerBaseInnerBase",
	127: "MapStringString2",
}

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 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 17:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField17(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 127:
			if fieldTypeId == thrift.MAP {
				if err = p.ReadField127(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) 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 *InnerBasePartial) 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 *InnerBasePartial) ReadField17(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapDoubleString = make(map[float64]string, size)
	for i := 0; i < size; i++ {
		var _key float64
		if v, err := iprot.ReadDouble(); err != nil {
			return err
		} else {
			_key = v
		}

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

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

func (p *InnerBasePartial) ReadField18(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return err
	}
	p.ListInnerBase = make([]*InnerBasePartial, 0, size)
	for i := 0; i < size; i++ {
		_elem := NewInnerBasePartial()
		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 *InnerBasePartial) ReadField19(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapInnerBaseInnerBase = make(map[*InnerBasePartial]*InnerBasePartial, size)
	for i := 0; i < size; i++ {
		_key := NewInnerBasePartial()
		if err := _key.Read(iprot); err != nil {
			return err
		}
		_val := NewInnerBasePartial()
		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 *InnerBasePartial) ReadField127(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return err
	}
	p.MapStringString2 = 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.MapStringString2[_key] = _val
	}
	if err := iprot.ReadMapEnd(); 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.writeField8(oprot); err != nil {
			fieldId = 8
			goto WriteFieldError
		}
		if err = p.writeField9(oprot); err != nil {
			fieldId = 9
			goto WriteFieldError
		}
		if err = p.writeField17(oprot); err != nil {
			fieldId = 17
			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.writeField127(oprot); err != nil {
			fieldId = 127
			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) 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 *InnerBasePartial) 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 *InnerBasePartial) writeField17(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("MapDoubleString", thrift.MAP, 17); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteMapBegin(thrift.DOUBLE, thrift.STRING, len(p.MapDoubleString)); err != nil {
		return err
	}
	for k, v := range p.MapDoubleString {

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

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

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

		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 127 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 127 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.Field8DeepEqual(ano.ListInt32) {
		return false
	}
	if !p.Field9DeepEqual(ano.MapStringString) {
		return false
	}
	if !p.Field17DeepEqual(ano.MapDoubleString) {
		return false
	}
	if !p.Field18DeepEqual(ano.ListInnerBase) {
		return false
	}
	if !p.Field19DeepEqual(ano.MapInnerBaseInnerBase) {
		return false
	}
	if !p.Field127DeepEqual(ano.MapStringString2) {
		return false
	}
	return true
}

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

	if p.Bool != src {
		return false
	}
	return true
}
func (p *InnerBasePartial) 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 *InnerBasePartial) 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 *InnerBasePartial) Field17DeepEqual(src map[float64]string) bool {

	if len(p.MapDoubleString) != len(src) {
		return false
	}
	for k, v := range p.MapDoubleString {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}
func (p *InnerBasePartial) Field18DeepEqual(src []*InnerBasePartial) 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 *InnerBasePartial) Field19DeepEqual(src map[*InnerBasePartial]*InnerBasePartial) 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 *InnerBasePartial) Field127DeepEqual(src map[string]string) bool {

	if len(p.MapStringString2) != len(src) {
		return false
	}
	for k, v := range p.MapStringString2 {
		_src := src[k]
		if strings.Compare(v, _src) != 0 {
			return false
		}
	}
	return true
}

type BasePartial struct {
	TrafficEnv *base.TrafficEnv `thrift:"TrafficEnv,5" json:"TrafficEnv,omitempty"`
}

func NewBasePartial() *BasePartial {
	return &BasePartial{}
}

var BasePartial_TrafficEnv_DEFAULT *base.TrafficEnv

func (p *BasePartial) GetTrafficEnv() (v *base.TrafficEnv) {
	if !p.IsSetTrafficEnv() {
		return BasePartial_TrafficEnv_DEFAULT
	}
	return p.TrafficEnv
}
func (p *BasePartial) SetTrafficEnv(val *base.TrafficEnv) {
	p.TrafficEnv = val
}

var fieldIDToName_BasePartial = map[int16]string{
	5: "TrafficEnv",
}

func (p *BasePartial) IsSetTrafficEnv() bool {
	return p.TrafficEnv != nil
}

func (p *BasePartial) 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 5:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BasePartial[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 *BasePartial) ReadField5(iprot thrift.TProtocol) error {
	p.TrafficEnv = base.NewTrafficEnv()
	if err := p.TrafficEnv.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *BasePartial) Field5DeepEqual(src *base.TrafficEnv) bool {

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

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

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

var ExampleReq_Msg_DEFAULT string

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

var ExampleReq_A_DEFAULT int32

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

var ExampleReq_InnerBase_DEFAULT *InnerBase

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

var ExampleReq_Base_DEFAULT *base.Base

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

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

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

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

func (p *ExampleReq) IsSetA() bool {
	return p.A != 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 issetBase bool = false

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

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

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

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

	if !issetBase {
		fieldId = 255
		goto RequiredFieldNotSetError
	}
	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleReq[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
RequiredFieldNotSetError:
	return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field %s is not set", fieldIDToName_ExampleReq[fieldId]))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if p.Msg == src {
		return true
	} else if p.Msg == nil || src == nil {
		return false
	}
	if strings.Compare(*p.Msg, *src) != 0 {
		return false
	}
	return true
}
func (p *ExampleReq) Field2DeepEqual(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 *ExampleReq) Field3DeepEqual(src *InnerBase) bool {

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

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

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

type ExampleSuper struct {
	Msg       *string    `thrift:"Msg,1" json:"Msg,omitempty"`
	A         *int32     `thrift:"A,2" json:"A,omitempty"`
	InnerBase *InnerBase `thrift:"InnerBase,3" json:"InnerBase"`
	Ex1       string     `thrift:"Ex1,4" json:"Ex1"`
	Ex2       *string    `thrift:"Ex2,5" json:"Ex2,omitempty"`
	Ex3       *string    `thrift:"Ex3,6" json:"Ex3,omitempty"`
	Ex4       string     `thrift:"Ex4,7,required" json:"Ex4"`
	SelfRef   *SelfRef   `thrift:"SelfRef,9" json:"SelfRef"`
	Base      *base.Base `thrift:"Base,255,required" json:"Base"`
	Subfix    float64    `thrift:"Subfix,32767" json:"Subfix"`
}

func NewExampleSuper() *ExampleSuper {
	return &ExampleSuper{}
}

var ExampleSuper_Msg_DEFAULT string

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

var ExampleSuper_A_DEFAULT int32

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

var ExampleSuper_InnerBase_DEFAULT *InnerBase

func (p *ExampleSuper) GetInnerBase() (v *InnerBase) {
	if !p.IsSetInnerBase() {
		return ExampleSuper_InnerBase_DEFAULT
	}
	return p.InnerBase
}

func (p *ExampleSuper) GetEx1() (v string) {
	return p.Ex1
}

var ExampleSuper_Ex2_DEFAULT string

func (p *ExampleSuper) GetEx2() (v string) {
	if !p.IsSetEx2() {
		return ExampleSuper_Ex2_DEFAULT
	}
	return *p.Ex2
}

var ExampleSuper_Ex3_DEFAULT string

func (p *ExampleSuper) GetEx3() (v string) {
	if !p.IsSetEx3() {
		return ExampleSuper_Ex3_DEFAULT
	}
	return *p.Ex3
}

func (p *ExampleSuper) GetEx4() (v string) {
	return p.Ex4
}

var ExampleSuper_SelfRef_DEFAULT *SelfRef

func (p *ExampleSuper) GetSelfRef() (v *SelfRef) {
	if !p.IsSetSelfRef() {
		return ExampleSuper_SelfRef_DEFAULT
	}
	return p.SelfRef
}

var ExampleSuper_Base_DEFAULT *base.Base

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

func (p *ExampleSuper) GetSubfix() (v float64) {
	return p.Subfix
}
func (p *ExampleSuper) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleSuper) SetA(val *int32) {
	p.A = val
}
func (p *ExampleSuper) SetInnerBase(val *InnerBase) {
	p.InnerBase = val
}
func (p *ExampleSuper) SetEx1(val string) {
	p.Ex1 = val
}
func (p *ExampleSuper) SetEx2(val *string) {
	p.Ex2 = val
}
func (p *ExampleSuper) SetEx3(val *string) {
	p.Ex3 = val
}
func (p *ExampleSuper) SetEx4(val string) {
	p.Ex4 = val
}
func (p *ExampleSuper) SetSelfRef(val *SelfRef) {
	p.SelfRef = val
}
func (p *ExampleSuper) SetBase(val *base.Base) {
	p.Base = val
}
func (p *ExampleSuper) SetSubfix(val float64) {
	p.Subfix = val
}

var fieldIDToName_ExampleSuper = map[int16]string{
	1:     "Msg",
	2:     "A",
	3:     "InnerBase",
	4:     "Ex1",
	5:     "Ex2",
	6:     "Ex3",
	7:     "Ex4",
	9:     "SelfRef",
	255:   "Base",
	32767: "Subfix",
}

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

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

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

func (p *ExampleSuper) IsSetEx2() bool {
	return p.Ex2 != nil
}

func (p *ExampleSuper) IsSetEx3() bool {
	return p.Ex3 != nil
}

func (p *ExampleSuper) IsSetSelfRef() bool {
	return p.SelfRef != nil
}

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

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

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

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

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

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.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.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.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
				}
			}
		case 7:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField7(iprot); err != nil {
					goto ReadFieldError
				}
				issetEx4 = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 9:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField9(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 255:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField255(iprot); err != nil {
					goto ReadFieldError
				}
				issetBase = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 32767:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField32767(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

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

	if !issetEx4 {
		fieldId = 7
		goto RequiredFieldNotSetError
	}

	if !issetBase {
		fieldId = 255
		goto RequiredFieldNotSetError
	}
	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleSuper[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_ExampleSuper[fieldId]))
}

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

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

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

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

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

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

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

func (p *ExampleSuper) ReadField9(iprot thrift.TProtocol) error {
	p.SelfRef = NewSelfRef()
	if err := p.SelfRef.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

func (p *ExampleSuper) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("ExampleSuper"); 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.writeField9(oprot); err != nil {
			fieldId = 9
			goto WriteFieldError
		}
		if err = p.writeField255(oprot); err != nil {
			fieldId = 255
			goto WriteFieldError
		}
		if err = p.writeField32767(oprot); err != nil {
			fieldId = 32767
			goto WriteFieldError
		}

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

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

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

func (p *ExampleSuper) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Ex1", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Ex1); 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 *ExampleSuper) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetEx2() {
		if err = oprot.WriteFieldBegin("Ex2", thrift.STRING, 5); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Ex2); 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 *ExampleSuper) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetEx3() {
		if err = oprot.WriteFieldBegin("Ex3", thrift.STRING, 6); err != nil {
			goto WriteFieldBeginError
		}
		if err := oprot.WriteString(*p.Ex3); 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 *ExampleSuper) writeField7(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("Ex4", thrift.STRING, 7); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Ex4); 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 *ExampleSuper) writeField9(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("SelfRef", thrift.STRUCT, 9); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.SelfRef.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 9 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 9 end error: ", p), err)
}

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

func (p *ExampleSuper) DeepEqual(ano *ExampleSuper) 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.A) {
		return false
	}
	if !p.Field3DeepEqual(ano.InnerBase) {
		return false
	}
	if !p.Field4DeepEqual(ano.Ex1) {
		return false
	}
	if !p.Field5DeepEqual(ano.Ex2) {
		return false
	}
	if !p.Field6DeepEqual(ano.Ex3) {
		return false
	}
	if !p.Field7DeepEqual(ano.Ex4) {
		return false
	}
	if !p.Field9DeepEqual(ano.SelfRef) {
		return false
	}
	if !p.Field255DeepEqual(ano.Base) {
		return false
	}
	if !p.Field32767DeepEqual(ano.Subfix) {
		return false
	}
	return true
}

func (p *ExampleSuper) 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 *ExampleSuper) Field2DeepEqual(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 *ExampleSuper) Field3DeepEqual(src *InnerBase) bool {

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

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

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

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

	if strings.Compare(p.Ex4, src) != 0 {
		return false
	}
	return true
}
func (p *ExampleSuper) Field9DeepEqual(src *SelfRef) bool {

	if !p.SelfRef.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleSuper) Field255DeepEqual(src *base.Base) bool {

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

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

type SelfRef struct {
	Self *SelfRef `thrift:"self,1" json:"self,omitempty"`
}

func NewSelfRef() *SelfRef {
	return &SelfRef{}
}

var SelfRef_Self_DEFAULT *SelfRef

func (p *SelfRef) GetSelf() (v *SelfRef) {
	if !p.IsSetSelf() {
		return SelfRef_Self_DEFAULT
	}
	return p.Self
}
func (p *SelfRef) SetSelf(val *SelfRef) {
	p.Self = val
}

var fieldIDToName_SelfRef = map[int16]string{
	1: "self",
}

func (p *SelfRef) IsSetSelf() bool {
	return p.Self != nil
}

func (p *SelfRef) 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_SelfRef[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 *SelfRef) ReadField1(iprot thrift.TProtocol) error {
	p.Self = NewSelfRef()
	if err := p.Self.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

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

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

type ExampleReqPartial struct {
	Msg       *string           `thrift:"Msg,1" json:"Msg,omitempty"`
	InnerBase *InnerBasePartial `thrift:"InnerBase,3" json:"InnerBase"`
	Base      *BasePartial      `thrift:"Base,255" json:"Base"`
}

func NewExampleReqPartial() *ExampleReqPartial {
	return &ExampleReqPartial{}
}

var ExampleReqPartial_Msg_DEFAULT string

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

var ExampleReqPartial_InnerBase_DEFAULT *InnerBasePartial

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

var ExampleReqPartial_Base_DEFAULT *BasePartial

func (p *ExampleReqPartial) GetBase() (v *BasePartial) {
	if !p.IsSetBase() {
		return ExampleReqPartial_Base_DEFAULT
	}
	return p.Base
}
func (p *ExampleReqPartial) SetMsg(val *string) {
	p.Msg = val
}
func (p *ExampleReqPartial) SetInnerBase(val *InnerBasePartial) {
	p.InnerBase = val
}
func (p *ExampleReqPartial) SetBase(val *BasePartial) {
	p.Base = val
}

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

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

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

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

func (p *ExampleReqPartial) 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 3:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 255:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField255(iprot); err != nil {
					goto ReadFieldError
				}
			} 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_ExampleReqPartial[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 *ExampleReqPartial) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Msg = &v
	}
	return nil
}

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

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

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

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

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

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

func (p *ExampleReqPartial) 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 *ExampleReqPartial) Field3DeepEqual(src *InnerBasePartial) bool {

	if !p.InnerBase.DeepEqual(src) {
		return false
	}
	return true
}
func (p *ExampleReqPartial) Field255DeepEqual(src *BasePartial) bool {

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

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

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

var ExampleResp_Msg_DEFAULT string

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

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

var ExampleResp_BaseResp_DEFAULT *base.BaseResp

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

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

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

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

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

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

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

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

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
				issetRequiredField = true
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 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 !issetRequiredField {
		fieldId = 2
		goto RequiredFieldNotSetError
	}
	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ExampleResp[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
RequiredFieldNotSetError:
	return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field %s is not set", fieldIDToName_ExampleResp[fieldId]))
}

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

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

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

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

func (p *ExampleResp) 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.RequiredField) {
		return false
	}
	if !p.Field255DeepEqual(ano.BaseResp) {
		return false
	}
	return true
}

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

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

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

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

type A struct {
	Self *A `thrift:"self,1" json:"self"`
}

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

var A_Self_DEFAULT *A

func (p *A) GetSelf() (v *A) {
	if !p.IsSetSelf() {
		return A_Self_DEFAULT
	}
	return p.Self
}
func (p *A) SetSelf(val *A) {
	p.Self = val
}

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

func (p *A) IsSetSelf() bool {
	return p.Self != nil
}

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.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_A[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

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

func (p *A) ReadField1(iprot thrift.TProtocol) error {
	p.Self = NewA()
	if err := p.Self.Read(iprot); err != nil {
		return err
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

func (p *Exception) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("code", thrift.I32, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(p.Code); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

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

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

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

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

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

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

type ExampleService interface {
	ExampleMethod(ctx context.Context, req *ExampleReq) (r *ExampleResp, err error)

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

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

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

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

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

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

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) ExamplePartialMethod(ctx context.Context, req *ExampleReqPartial) (r *A, err error) {
	var _args ExampleServiceExamplePartialMethodArgs
	_args.Req = req
	var _result ExampleServiceExamplePartialMethodResult
	if err = p.Client_().Call(ctx, "ExamplePartialMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

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

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

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

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

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

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("ExamplePartialMethod", &exampleServiceProcessorExamplePartialMethod{handler: handler})
	self.AddToProcessorMap("ExampleSuperMethod", &exampleServiceProcessorExampleSuperMethod{handler: handler})
	self.AddToProcessorMap("Foo", &exampleServiceProcessorFoo{handler: handler})
	self.AddToProcessorMap("Ping", &exampleServiceProcessorPing{handler: handler})
	self.AddToProcessorMap("Oneway", &exampleServiceProcessorOneway{handler: handler})
	self.AddToProcessorMap("Void", &exampleServiceProcessorVoid{handler: handler})
	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 exampleServiceProcessorExamplePartialMethod struct {
	handler ExampleService
}

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

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

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

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

type exampleServiceProcessorFoo struct {
	handler ExampleService
}

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

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

type exampleServiceProcessorPing struct {
	handler ExampleService
}

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

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

type exampleServiceProcessorOneway struct {
	handler ExampleService
}

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

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

type exampleServiceProcessorVoid struct {
	handler ExampleService
}

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

	iprot.ReadMessageEnd()
	var err2 error
	result := ExampleServiceVoidResult{}
	if err2 = p.handler.Void(ctx, args.Msg); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing Void: "+err2.Error())
		oprot.WriteMessageBegin("Void", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush(ctx)
		return true, err2
	}
	if err2 = oprot.WriteMessageBegin("Void", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type 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 ExampleServiceExamplePartialMethodArgs struct {
	Req *ExampleReqPartial `thrift:"req,1" json:"req"`
}

func NewExampleServiceExamplePartialMethodArgs() *ExampleServiceExamplePartialMethodArgs {
	return &ExampleServiceExamplePartialMethodArgs{}
}

var ExampleServiceExamplePartialMethodArgs_Req_DEFAULT *ExampleReqPartial

func (p *ExampleServiceExamplePartialMethodArgs) GetReq() (v *ExampleReqPartial) {
	if !p.IsSetReq() {
		return ExampleServiceExamplePartialMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExamplePartialMethodArgs) SetReq(val *ExampleReqPartial) {
	p.Req = val
}

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

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

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

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

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

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

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

func NewExampleServiceExamplePartialMethodResult() *ExampleServiceExamplePartialMethodResult {
	return &ExampleServiceExamplePartialMethodResult{}
}

var ExampleServiceExamplePartialMethodResult_Success_DEFAULT *A

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

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

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

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

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

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

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

type ExampleServiceExampleSuperMethodArgs struct {
	Req *ExampleSuper `thrift:"req,1" json:"req"`
}

func NewExampleServiceExampleSuperMethodArgs() *ExampleServiceExampleSuperMethodArgs {
	return &ExampleServiceExampleSuperMethodArgs{}
}

var ExampleServiceExampleSuperMethodArgs_Req_DEFAULT *ExampleSuper

func (p *ExampleServiceExampleSuperMethodArgs) GetReq() (v *ExampleSuper) {
	if !p.IsSetReq() {
		return ExampleServiceExampleSuperMethodArgs_Req_DEFAULT
	}
	return p.Req
}
func (p *ExampleServiceExampleSuperMethodArgs) SetReq(val *ExampleSuper) {
	p.Req = val
}

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

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

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

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

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

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

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

func NewExampleServiceExampleSuperMethodResult() *ExampleServiceExampleSuperMethodResult {
	return &ExampleServiceExampleSuperMethodResult{}
}

var ExampleServiceExampleSuperMethodResult_Success_DEFAULT *A

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

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

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

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

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

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

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

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

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

var ExampleServiceFooArgs_Req_DEFAULT *A

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var ExampleServiceFooResult_Success_DEFAULT *A

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

func (p *ExampleServiceFooResult) Field0DeepEqual(src *A) bool {

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

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

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var ExampleServicePingResult_Success_DEFAULT string

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

func (p *ExampleServicePingResult) Field0DeepEqual(src *string) bool {

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

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

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ExampleServiceVoidResult struct {
}

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

var fieldIDToName_ExampleServiceVoidResult = map[int16]string{}

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

	var fieldTypeId thrift.TType
	var fieldId int16

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

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

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

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
SkipFieldTypeError:
	return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, fieldTypeId), err)

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

func (p *ExampleServiceVoidResult) Write(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteStructBegin("Void_result"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {

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

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

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