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

// Code generated by Kitex v0.7.2. DO NOT EDIT.

package testservice2

import (
	"context"
	example2 "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2"
	client "github.com/cloudwego/kitex/client"
	kitex "github.com/cloudwego/kitex/pkg/serviceinfo"
	streaming "github.com/cloudwego/kitex/pkg/streaming"
	proto "google.golang.org/protobuf/proto"
)

func serviceInfo() *kitex.ServiceInfo {
	return testService2ServiceInfo
}

var testService2ServiceInfo = NewServiceInfo()

func NewServiceInfo() *kitex.ServiceInfo {
	serviceName := "TestService2"
	handlerType := (*example2.TestService2)(nil)
	methods := map[string]kitex.MethodInfo{
		"ExampleMethod":         kitex.NewMethodInfo(exampleMethodHandler, newExampleMethodArgs, newExampleMethodResult, false),
		"ExamplePartialMethod":  kitex.NewMethodInfo(examplePartialMethodHandler, newExamplePartialMethodArgs, newExamplePartialMethodResult, false),
		"ExamplePartialMethod2": kitex.NewMethodInfo(examplePartialMethod2Handler, newExamplePartialMethod2Args, newExamplePartialMethod2Result, false),
		"ExampleSuperMethod":    kitex.NewMethodInfo(exampleSuperMethodHandler, newExampleSuperMethodArgs, newExampleSuperMethodResult, false),
		"Int2FloatMethod":       kitex.NewMethodInfo(int2FloatMethodHandler, newInt2FloatMethodArgs, newInt2FloatMethodResult, false),
		"Foo":                   kitex.NewMethodInfo(fooHandler, newFooArgs, newFooResult, false),
		"Ping":                  kitex.NewMethodInfo(pingHandler, newPingArgs, newPingResult, false),
		"Oneway":                kitex.NewMethodInfo(onewayHandler, newOnewayArgs, newOnewayResult, false),
		"Void":                  kitex.NewMethodInfo(voidHandler, newVoidArgs, newVoidResult, false),
	}
	extra := map[string]interface{}{
		"PackageName":     "pb3",
		"ServiceFilePath": ``,
	}
	svcInfo := &kitex.ServiceInfo{
		ServiceName:     serviceName,
		HandlerType:     handlerType,
		Methods:         methods,
		PayloadCodec:    kitex.Protobuf,
		KiteXGenVersion: "v0.7.2",
		Extra:           extra,
	}
	return svcInfo
}

func exampleMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.ExampleReq)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).ExampleMethod(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *ExampleMethodArgs:
		success, err := handler.(example2.TestService2).ExampleMethod(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*ExampleMethodResult)
		realResult.Success = success
	}
	return nil
}
func newExampleMethodArgs() interface{} {
	return &ExampleMethodArgs{}
}

func newExampleMethodResult() interface{} {
	return &ExampleMethodResult{}
}

type ExampleMethodArgs struct {
	Req *example2.ExampleReq
}

func (p *ExampleMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.ExampleReq)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *ExampleMethodArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *ExampleMethodArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *ExampleMethodArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *ExampleMethodArgs) Unmarshal(in []byte) error {
	msg := new(example2.ExampleReq)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var ExampleMethodArgs_Req_DEFAULT *example2.ExampleReq

func (p *ExampleMethodArgs) GetReq() *example2.ExampleReq {
	if !p.IsSetReq() {
		return ExampleMethodArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *ExampleMethodArgs) GetFirstArgument() interface{} {
	return p.Req
}

type ExampleMethodResult struct {
	Success *example2.ExampleResp
}

var ExampleMethodResult_Success_DEFAULT *example2.ExampleResp

func (p *ExampleMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.ExampleResp)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *ExampleMethodResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *ExampleMethodResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *ExampleMethodResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *ExampleMethodResult) Unmarshal(in []byte) error {
	msg := new(example2.ExampleResp)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *ExampleMethodResult) GetSuccess() *example2.ExampleResp {
	if !p.IsSetSuccess() {
		return ExampleMethodResult_Success_DEFAULT
	}
	return p.Success
}

func (p *ExampleMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.ExampleResp)
}

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

func (p *ExampleMethodResult) GetResult() interface{} {
	return p.Success
}

func examplePartialMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.ExampleReqPartial)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).ExamplePartialMethod(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *ExamplePartialMethodArgs:
		success, err := handler.(example2.TestService2).ExamplePartialMethod(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*ExamplePartialMethodResult)
		realResult.Success = success
	}
	return nil
}
func newExamplePartialMethodArgs() interface{} {
	return &ExamplePartialMethodArgs{}
}

func newExamplePartialMethodResult() interface{} {
	return &ExamplePartialMethodResult{}
}

type ExamplePartialMethodArgs struct {
	Req *example2.ExampleReqPartial
}

func (p *ExamplePartialMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.ExampleReqPartial)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *ExamplePartialMethodArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *ExamplePartialMethodArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *ExamplePartialMethodArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *ExamplePartialMethodArgs) Unmarshal(in []byte) error {
	msg := new(example2.ExampleReqPartial)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var ExamplePartialMethodArgs_Req_DEFAULT *example2.ExampleReqPartial

func (p *ExamplePartialMethodArgs) GetReq() *example2.ExampleReqPartial {
	if !p.IsSetReq() {
		return ExamplePartialMethodArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *ExamplePartialMethodArgs) GetFirstArgument() interface{} {
	return p.Req
}

type ExamplePartialMethodResult struct {
	Success *example2.A
}

var ExamplePartialMethodResult_Success_DEFAULT *example2.A

func (p *ExamplePartialMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.A)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *ExamplePartialMethodResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *ExamplePartialMethodResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *ExamplePartialMethodResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *ExamplePartialMethodResult) Unmarshal(in []byte) error {
	msg := new(example2.A)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *ExamplePartialMethodResult) GetSuccess() *example2.A {
	if !p.IsSetSuccess() {
		return ExamplePartialMethodResult_Success_DEFAULT
	}
	return p.Success
}

func (p *ExamplePartialMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.A)
}

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

func (p *ExamplePartialMethodResult) GetResult() interface{} {
	return p.Success
}

func examplePartialMethod2Handler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.ExampleReqPartial)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).ExamplePartialMethod2(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *ExamplePartialMethod2Args:
		success, err := handler.(example2.TestService2).ExamplePartialMethod2(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*ExamplePartialMethod2Result)
		realResult.Success = success
	}
	return nil
}
func newExamplePartialMethod2Args() interface{} {
	return &ExamplePartialMethod2Args{}
}

func newExamplePartialMethod2Result() interface{} {
	return &ExamplePartialMethod2Result{}
}

type ExamplePartialMethod2Args struct {
	Req *example2.ExampleReqPartial
}

func (p *ExamplePartialMethod2Args) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.ExampleReqPartial)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *ExamplePartialMethod2Args) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *ExamplePartialMethod2Args) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *ExamplePartialMethod2Args) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *ExamplePartialMethod2Args) Unmarshal(in []byte) error {
	msg := new(example2.ExampleReqPartial)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var ExamplePartialMethod2Args_Req_DEFAULT *example2.ExampleReqPartial

func (p *ExamplePartialMethod2Args) GetReq() *example2.ExampleReqPartial {
	if !p.IsSetReq() {
		return ExamplePartialMethod2Args_Req_DEFAULT
	}
	return p.Req
}

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

func (p *ExamplePartialMethod2Args) GetFirstArgument() interface{} {
	return p.Req
}

type ExamplePartialMethod2Result struct {
	Success *example2.ExampleRespPartial
}

var ExamplePartialMethod2Result_Success_DEFAULT *example2.ExampleRespPartial

func (p *ExamplePartialMethod2Result) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.ExampleRespPartial)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *ExamplePartialMethod2Result) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *ExamplePartialMethod2Result) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *ExamplePartialMethod2Result) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *ExamplePartialMethod2Result) Unmarshal(in []byte) error {
	msg := new(example2.ExampleRespPartial)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *ExamplePartialMethod2Result) GetSuccess() *example2.ExampleRespPartial {
	if !p.IsSetSuccess() {
		return ExamplePartialMethod2Result_Success_DEFAULT
	}
	return p.Success
}

func (p *ExamplePartialMethod2Result) SetSuccess(x interface{}) {
	p.Success = x.(*example2.ExampleRespPartial)
}

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

func (p *ExamplePartialMethod2Result) GetResult() interface{} {
	return p.Success
}

func exampleSuperMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.ExampleSuper)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).ExampleSuperMethod(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *ExampleSuperMethodArgs:
		success, err := handler.(example2.TestService2).ExampleSuperMethod(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*ExampleSuperMethodResult)
		realResult.Success = success
	}
	return nil
}
func newExampleSuperMethodArgs() interface{} {
	return &ExampleSuperMethodArgs{}
}

func newExampleSuperMethodResult() interface{} {
	return &ExampleSuperMethodResult{}
}

type ExampleSuperMethodArgs struct {
	Req *example2.ExampleSuper
}

func (p *ExampleSuperMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.ExampleSuper)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *ExampleSuperMethodArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *ExampleSuperMethodArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *ExampleSuperMethodArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *ExampleSuperMethodArgs) Unmarshal(in []byte) error {
	msg := new(example2.ExampleSuper)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var ExampleSuperMethodArgs_Req_DEFAULT *example2.ExampleSuper

func (p *ExampleSuperMethodArgs) GetReq() *example2.ExampleSuper {
	if !p.IsSetReq() {
		return ExampleSuperMethodArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *ExampleSuperMethodArgs) GetFirstArgument() interface{} {
	return p.Req
}

type ExampleSuperMethodResult struct {
	Success *example2.A
}

var ExampleSuperMethodResult_Success_DEFAULT *example2.A

func (p *ExampleSuperMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.A)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *ExampleSuperMethodResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *ExampleSuperMethodResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *ExampleSuperMethodResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *ExampleSuperMethodResult) Unmarshal(in []byte) error {
	msg := new(example2.A)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *ExampleSuperMethodResult) GetSuccess() *example2.A {
	if !p.IsSetSuccess() {
		return ExampleSuperMethodResult_Success_DEFAULT
	}
	return p.Success
}

func (p *ExampleSuperMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.A)
}

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

func (p *ExampleSuperMethodResult) GetResult() interface{} {
	return p.Success
}

func int2FloatMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.ExampleInt2Float)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).Int2FloatMethod(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *Int2FloatMethodArgs:
		success, err := handler.(example2.TestService2).Int2FloatMethod(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*Int2FloatMethodResult)
		realResult.Success = success
	}
	return nil
}
func newInt2FloatMethodArgs() interface{} {
	return &Int2FloatMethodArgs{}
}

func newInt2FloatMethodResult() interface{} {
	return &Int2FloatMethodResult{}
}

type Int2FloatMethodArgs struct {
	Req *example2.ExampleInt2Float
}

func (p *Int2FloatMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.ExampleInt2Float)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *Int2FloatMethodArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *Int2FloatMethodArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *Int2FloatMethodArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *Int2FloatMethodArgs) Unmarshal(in []byte) error {
	msg := new(example2.ExampleInt2Float)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var Int2FloatMethodArgs_Req_DEFAULT *example2.ExampleInt2Float

func (p *Int2FloatMethodArgs) GetReq() *example2.ExampleInt2Float {
	if !p.IsSetReq() {
		return Int2FloatMethodArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *Int2FloatMethodArgs) GetFirstArgument() interface{} {
	return p.Req
}

type Int2FloatMethodResult struct {
	Success *example2.ExampleInt2Float
}

var Int2FloatMethodResult_Success_DEFAULT *example2.ExampleInt2Float

func (p *Int2FloatMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.ExampleInt2Float)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *Int2FloatMethodResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *Int2FloatMethodResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *Int2FloatMethodResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *Int2FloatMethodResult) Unmarshal(in []byte) error {
	msg := new(example2.ExampleInt2Float)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *Int2FloatMethodResult) GetSuccess() *example2.ExampleInt2Float {
	if !p.IsSetSuccess() {
		return Int2FloatMethodResult_Success_DEFAULT
	}
	return p.Success
}

func (p *Int2FloatMethodResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.ExampleInt2Float)
}

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

func (p *Int2FloatMethodResult) GetResult() interface{} {
	return p.Success
}

func fooHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.A)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).Foo(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *FooArgs:
		success, err := handler.(example2.TestService2).Foo(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*FooResult)
		realResult.Success = success
	}
	return nil
}
func newFooArgs() interface{} {
	return &FooArgs{}
}

func newFooResult() interface{} {
	return &FooResult{}
}

type FooArgs struct {
	Req *example2.A
}

func (p *FooArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.A)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *FooArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *FooArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *FooArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *FooArgs) Unmarshal(in []byte) error {
	msg := new(example2.A)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var FooArgs_Req_DEFAULT *example2.A

func (p *FooArgs) GetReq() *example2.A {
	if !p.IsSetReq() {
		return FooArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *FooArgs) GetFirstArgument() interface{} {
	return p.Req
}

type FooResult struct {
	Success *example2.A
}

var FooResult_Success_DEFAULT *example2.A

func (p *FooResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.A)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *FooResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *FooResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *FooResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *FooResult) Unmarshal(in []byte) error {
	msg := new(example2.A)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *FooResult) GetSuccess() *example2.A {
	if !p.IsSetSuccess() {
		return FooResult_Success_DEFAULT
	}
	return p.Success
}

func (p *FooResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.A)
}

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

func (p *FooResult) GetResult() interface{} {
	return p.Success
}

func pingHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.A)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).Ping(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *PingArgs:
		success, err := handler.(example2.TestService2).Ping(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*PingResult)
		realResult.Success = success
	}
	return nil
}
func newPingArgs() interface{} {
	return &PingArgs{}
}

func newPingResult() interface{} {
	return &PingResult{}
}

type PingArgs struct {
	Req *example2.A
}

func (p *PingArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.A)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *PingArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *PingArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *PingArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *PingArgs) Unmarshal(in []byte) error {
	msg := new(example2.A)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var PingArgs_Req_DEFAULT *example2.A

func (p *PingArgs) GetReq() *example2.A {
	if !p.IsSetReq() {
		return PingArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *PingArgs) GetFirstArgument() interface{} {
	return p.Req
}

type PingResult struct {
	Success *example2.PingResponse
}

var PingResult_Success_DEFAULT *example2.PingResponse

func (p *PingResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.PingResponse)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *PingResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *PingResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *PingResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *PingResult) Unmarshal(in []byte) error {
	msg := new(example2.PingResponse)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *PingResult) GetSuccess() *example2.PingResponse {
	if !p.IsSetSuccess() {
		return PingResult_Success_DEFAULT
	}
	return p.Success
}

func (p *PingResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.PingResponse)
}

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

func (p *PingResult) GetResult() interface{} {
	return p.Success
}

func onewayHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.OnewayRequest)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).Oneway(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *OnewayArgs:
		success, err := handler.(example2.TestService2).Oneway(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*OnewayResult)
		realResult.Success = success
	}
	return nil
}
func newOnewayArgs() interface{} {
	return &OnewayArgs{}
}

func newOnewayResult() interface{} {
	return &OnewayResult{}
}

type OnewayArgs struct {
	Req *example2.OnewayRequest
}

func (p *OnewayArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.OnewayRequest)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *OnewayArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *OnewayArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *OnewayArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *OnewayArgs) Unmarshal(in []byte) error {
	msg := new(example2.OnewayRequest)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var OnewayArgs_Req_DEFAULT *example2.OnewayRequest

func (p *OnewayArgs) GetReq() *example2.OnewayRequest {
	if !p.IsSetReq() {
		return OnewayArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *OnewayArgs) GetFirstArgument() interface{} {
	return p.Req
}

type OnewayResult struct {
	Success *example2.VoidResponse
}

var OnewayResult_Success_DEFAULT *example2.VoidResponse

func (p *OnewayResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.VoidResponse)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *OnewayResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *OnewayResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *OnewayResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *OnewayResult) Unmarshal(in []byte) error {
	msg := new(example2.VoidResponse)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *OnewayResult) GetSuccess() *example2.VoidResponse {
	if !p.IsSetSuccess() {
		return OnewayResult_Success_DEFAULT
	}
	return p.Success
}

func (p *OnewayResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.VoidResponse)
}

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

func (p *OnewayResult) GetResult() interface{} {
	return p.Success
}

func voidHandler(ctx context.Context, handler interface{}, arg, result interface{}) error {
	switch s := arg.(type) {
	case *streaming.Args:
		st := s.Stream
		req := new(example2.VoidRequest)
		if err := st.RecvMsg(req); err != nil {
			return err
		}
		resp, err := handler.(example2.TestService2).Void(ctx, req)
		if err != nil {
			return err
		}
		if err := st.SendMsg(resp); err != nil {
			return err
		}
	case *VoidArgs:
		success, err := handler.(example2.TestService2).Void(ctx, s.Req)
		if err != nil {
			return err
		}
		realResult := result.(*VoidResult)
		realResult.Success = success
	}
	return nil
}
func newVoidArgs() interface{} {
	return &VoidArgs{}
}

func newVoidResult() interface{} {
	return &VoidResult{}
}

type VoidArgs struct {
	Req *example2.VoidRequest
}

func (p *VoidArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetReq() {
		p.Req = new(example2.VoidRequest)
	}
	return p.Req.FastRead(buf, _type, number)
}

func (p *VoidArgs) FastWrite(buf []byte) (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.FastWrite(buf)
}

func (p *VoidArgs) Size() (n int) {
	if !p.IsSetReq() {
		return 0
	}
	return p.Req.Size()
}

func (p *VoidArgs) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetReq() {
		return out, nil
	}
	return proto.Marshal(p.Req)
}

func (p *VoidArgs) Unmarshal(in []byte) error {
	msg := new(example2.VoidRequest)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Req = msg
	return nil
}

var VoidArgs_Req_DEFAULT *example2.VoidRequest

func (p *VoidArgs) GetReq() *example2.VoidRequest {
	if !p.IsSetReq() {
		return VoidArgs_Req_DEFAULT
	}
	return p.Req
}

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

func (p *VoidArgs) GetFirstArgument() interface{} {
	return p.Req
}

type VoidResult struct {
	Success *example2.VoidResponse
}

var VoidResult_Success_DEFAULT *example2.VoidResponse

func (p *VoidResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) {
	if !p.IsSetSuccess() {
		p.Success = new(example2.VoidResponse)
	}
	return p.Success.FastRead(buf, _type, number)
}

func (p *VoidResult) FastWrite(buf []byte) (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.FastWrite(buf)
}

func (p *VoidResult) Size() (n int) {
	if !p.IsSetSuccess() {
		return 0
	}
	return p.Success.Size()
}

func (p *VoidResult) Marshal(out []byte) ([]byte, error) {
	if !p.IsSetSuccess() {
		return out, nil
	}
	return proto.Marshal(p.Success)
}

func (p *VoidResult) Unmarshal(in []byte) error {
	msg := new(example2.VoidResponse)
	if err := proto.Unmarshal(in, msg); err != nil {
		return err
	}
	p.Success = msg
	return nil
}

func (p *VoidResult) GetSuccess() *example2.VoidResponse {
	if !p.IsSetSuccess() {
		return VoidResult_Success_DEFAULT
	}
	return p.Success
}

func (p *VoidResult) SetSuccess(x interface{}) {
	p.Success = x.(*example2.VoidResponse)
}

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

func (p *VoidResult) GetResult() interface{} {
	return p.Success
}

type kClient struct {
	c client.Client
}

func newServiceClient(c client.Client) *kClient {
	return &kClient{
		c: c,
	}
}

func (p *kClient) ExampleMethod(ctx context.Context, Req *example2.ExampleReq) (r *example2.ExampleResp, err error) {
	var _args ExampleMethodArgs
	_args.Req = Req
	var _result ExampleMethodResult
	if err = p.c.Call(ctx, "ExampleMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) ExamplePartialMethod(ctx context.Context, Req *example2.ExampleReqPartial) (r *example2.A, err error) {
	var _args ExamplePartialMethodArgs
	_args.Req = Req
	var _result ExamplePartialMethodResult
	if err = p.c.Call(ctx, "ExamplePartialMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) ExamplePartialMethod2(ctx context.Context, Req *example2.ExampleReqPartial) (r *example2.ExampleRespPartial, err error) {
	var _args ExamplePartialMethod2Args
	_args.Req = Req
	var _result ExamplePartialMethod2Result
	if err = p.c.Call(ctx, "ExamplePartialMethod2", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) ExampleSuperMethod(ctx context.Context, Req *example2.ExampleSuper) (r *example2.A, err error) {
	var _args ExampleSuperMethodArgs
	_args.Req = Req
	var _result ExampleSuperMethodResult
	if err = p.c.Call(ctx, "ExampleSuperMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) Int2FloatMethod(ctx context.Context, Req *example2.ExampleInt2Float) (r *example2.ExampleInt2Float, err error) {
	var _args Int2FloatMethodArgs
	_args.Req = Req
	var _result Int2FloatMethodResult
	if err = p.c.Call(ctx, "Int2FloatMethod", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) Foo(ctx context.Context, Req *example2.A) (r *example2.A, err error) {
	var _args FooArgs
	_args.Req = Req
	var _result FooResult
	if err = p.c.Call(ctx, "Foo", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) Ping(ctx context.Context, Req *example2.A) (r *example2.PingResponse, err error) {
	var _args PingArgs
	_args.Req = Req
	var _result PingResult
	if err = p.c.Call(ctx, "Ping", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) Oneway(ctx context.Context, Req *example2.OnewayRequest) (r *example2.VoidResponse, err error) {
	var _args OnewayArgs
	_args.Req = Req
	var _result OnewayResult
	if err = p.c.Call(ctx, "Oneway", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}

func (p *kClient) Void(ctx context.Context, Req *example2.VoidRequest) (r *example2.VoidResponse, err error) {
	var _args VoidArgs
	_args.Req = Req
	var _result VoidResult
	if err = p.c.Call(ctx, "Void", &_args, &_result); err != nil {
		return
	}
	return _result.GetSuccess(), nil
}