options_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package pb

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion7

// ServiceClient is the client API for Service service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ServiceClient interface {
	Mutate1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Mutate2(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Query1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Publish(ctx context.Context, opts ...grpc.CallOption) (Service_PublishClient, error)
	Subscribe(ctx context.Context, in *Data, opts ...grpc.CallOption) (Service_SubscribeClient, error)
	PubSub1(ctx context.Context, opts ...grpc.CallOption) (Service_PubSub1Client, error)
	InvalidSubscribe1(ctx context.Context, opts ...grpc.CallOption) (Service_InvalidSubscribe1Client, error)
	InvalidSubscribe2(ctx context.Context, in *Data, opts ...grpc.CallOption) (Service_InvalidSubscribe2Client, error)
	InvalidSubscribe3(ctx context.Context, opts ...grpc.CallOption) (Service_InvalidSubscribe3Client, error)
	PubSub2(ctx context.Context, opts ...grpc.CallOption) (Service_PubSub2Client, error)
}

type serviceClient struct {
	cc grpc.ClientConnInterface
}

func NewServiceClient(cc grpc.ClientConnInterface) ServiceClient {
	return &serviceClient{cc}
}

func (c *serviceClient) Mutate1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Service/Mutate1", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) Mutate2(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Service/Mutate2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) Query1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Service/Query1", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) Publish(ctx context.Context, opts ...grpc.CallOption) (Service_PublishClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[0], "/pb.Service/Publish", opts...)
	if err != nil {
		return nil, err
	}
	x := &servicePublishClient{stream}
	return x, nil
}

type Service_PublishClient interface {
	Send(*Data) error
	CloseAndRecv() (*Data, error)
	grpc.ClientStream
}

type servicePublishClient struct {
	grpc.ClientStream
}

func (x *servicePublishClient) Send(m *Data) error {
	return x.ClientStream.SendMsg(m)
}

func (x *servicePublishClient) CloseAndRecv() (*Data, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) Subscribe(ctx context.Context, in *Data, opts ...grpc.CallOption) (Service_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[1], "/pb.Service/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceSubscribeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Service_SubscribeClient interface {
	Recv() (*Data, error)
	grpc.ClientStream
}

type serviceSubscribeClient struct {
	grpc.ClientStream
}

func (x *serviceSubscribeClient) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) PubSub1(ctx context.Context, opts ...grpc.CallOption) (Service_PubSub1Client, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[2], "/pb.Service/PubSub1", opts...)
	if err != nil {
		return nil, err
	}
	x := &servicePubSub1Client{stream}
	return x, nil
}

type Service_PubSub1Client interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ClientStream
}

type servicePubSub1Client struct {
	grpc.ClientStream
}

func (x *servicePubSub1Client) Send(m *Data) error {
	return x.ClientStream.SendMsg(m)
}

func (x *servicePubSub1Client) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) InvalidSubscribe1(ctx context.Context, opts ...grpc.CallOption) (Service_InvalidSubscribe1Client, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[3], "/pb.Service/InvalidSubscribe1", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceInvalidSubscribe1Client{stream}
	return x, nil
}

type Service_InvalidSubscribe1Client interface {
	Send(*Data) error
	CloseAndRecv() (*Data, error)
	grpc.ClientStream
}

type serviceInvalidSubscribe1Client struct {
	grpc.ClientStream
}

func (x *serviceInvalidSubscribe1Client) Send(m *Data) error {
	return x.ClientStream.SendMsg(m)
}

func (x *serviceInvalidSubscribe1Client) CloseAndRecv() (*Data, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) InvalidSubscribe2(ctx context.Context, in *Data, opts ...grpc.CallOption) (Service_InvalidSubscribe2Client, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[4], "/pb.Service/InvalidSubscribe2", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceInvalidSubscribe2Client{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Service_InvalidSubscribe2Client interface {
	Recv() (*Data, error)
	grpc.ClientStream
}

type serviceInvalidSubscribe2Client struct {
	grpc.ClientStream
}

func (x *serviceInvalidSubscribe2Client) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) InvalidSubscribe3(ctx context.Context, opts ...grpc.CallOption) (Service_InvalidSubscribe3Client, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[5], "/pb.Service/InvalidSubscribe3", opts...)
	if err != nil {
		return nil, err
	}
	x := &serviceInvalidSubscribe3Client{stream}
	return x, nil
}

type Service_InvalidSubscribe3Client interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ClientStream
}

type serviceInvalidSubscribe3Client struct {
	grpc.ClientStream
}

func (x *serviceInvalidSubscribe3Client) Send(m *Data) error {
	return x.ClientStream.SendMsg(m)
}

func (x *serviceInvalidSubscribe3Client) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *serviceClient) PubSub2(ctx context.Context, opts ...grpc.CallOption) (Service_PubSub2Client, error) {
	stream, err := c.cc.NewStream(ctx, &_Service_serviceDesc.Streams[6], "/pb.Service/PubSub2", opts...)
	if err != nil {
		return nil, err
	}
	x := &servicePubSub2Client{stream}
	return x, nil
}

type Service_PubSub2Client interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ClientStream
}

type servicePubSub2Client struct {
	grpc.ClientStream
}

func (x *servicePubSub2Client) Send(m *Data) error {
	return x.ClientStream.SendMsg(m)
}

func (x *servicePubSub2Client) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ServiceServer is the server API for Service service.
// All implementations must embed UnimplementedServiceServer
// for forward compatibility
type ServiceServer interface {
	Mutate1(context.Context, *Data) (*Data, error)
	Mutate2(context.Context, *Data) (*Data, error)
	Query1(context.Context, *Data) (*Data, error)
	Publish(Service_PublishServer) error
	Subscribe(*Data, Service_SubscribeServer) error
	PubSub1(Service_PubSub1Server) error
	InvalidSubscribe1(Service_InvalidSubscribe1Server) error
	InvalidSubscribe2(*Data, Service_InvalidSubscribe2Server) error
	InvalidSubscribe3(Service_InvalidSubscribe3Server) error
	PubSub2(Service_PubSub2Server) error
	mustEmbedUnimplementedServiceServer()
}

// UnimplementedServiceServer must be embedded to have forward compatible implementations.
type UnimplementedServiceServer struct {
}

func (UnimplementedServiceServer) Mutate1(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mutate1 not implemented")
}
func (UnimplementedServiceServer) Mutate2(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mutate2 not implemented")
}
func (UnimplementedServiceServer) Query1(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query1 not implemented")
}
func (UnimplementedServiceServer) Publish(Service_PublishServer) error {
	return status.Errorf(codes.Unimplemented, "method Publish not implemented")
}
func (UnimplementedServiceServer) Subscribe(*Data, Service_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedServiceServer) PubSub1(Service_PubSub1Server) error {
	return status.Errorf(codes.Unimplemented, "method PubSub1 not implemented")
}
func (UnimplementedServiceServer) InvalidSubscribe1(Service_InvalidSubscribe1Server) error {
	return status.Errorf(codes.Unimplemented, "method InvalidSubscribe1 not implemented")
}
func (UnimplementedServiceServer) InvalidSubscribe2(*Data, Service_InvalidSubscribe2Server) error {
	return status.Errorf(codes.Unimplemented, "method InvalidSubscribe2 not implemented")
}
func (UnimplementedServiceServer) InvalidSubscribe3(Service_InvalidSubscribe3Server) error {
	return status.Errorf(codes.Unimplemented, "method InvalidSubscribe3 not implemented")
}
func (UnimplementedServiceServer) PubSub2(Service_PubSub2Server) error {
	return status.Errorf(codes.Unimplemented, "method PubSub2 not implemented")
}
func (UnimplementedServiceServer) mustEmbedUnimplementedServiceServer() {}

// UnsafeServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ServiceServer will
// result in compilation errors.
type UnsafeServiceServer interface {
	mustEmbedUnimplementedServiceServer()
}

func RegisterServiceServer(s grpc.ServiceRegistrar, srv ServiceServer) {
	s.RegisterService(&_Service_serviceDesc, srv)
}

func _Service_Mutate1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).Mutate1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Service/Mutate1",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).Mutate1(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_Mutate2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).Mutate2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Service/Mutate2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).Mutate2(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_Query1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).Query1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Service/Query1",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).Query1(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_Publish_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ServiceServer).Publish(&servicePublishServer{stream})
}

type Service_PublishServer interface {
	SendAndClose(*Data) error
	Recv() (*Data, error)
	grpc.ServerStream
}

type servicePublishServer struct {
	grpc.ServerStream
}

func (x *servicePublishServer) SendAndClose(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func (x *servicePublishServer) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Service_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Data)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).Subscribe(m, &serviceSubscribeServer{stream})
}

type Service_SubscribeServer interface {
	Send(*Data) error
	grpc.ServerStream
}

type serviceSubscribeServer struct {
	grpc.ServerStream
}

func (x *serviceSubscribeServer) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_PubSub1_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ServiceServer).PubSub1(&servicePubSub1Server{stream})
}

type Service_PubSub1Server interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ServerStream
}

type servicePubSub1Server struct {
	grpc.ServerStream
}

func (x *servicePubSub1Server) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func (x *servicePubSub1Server) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Service_InvalidSubscribe1_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ServiceServer).InvalidSubscribe1(&serviceInvalidSubscribe1Server{stream})
}

type Service_InvalidSubscribe1Server interface {
	SendAndClose(*Data) error
	Recv() (*Data, error)
	grpc.ServerStream
}

type serviceInvalidSubscribe1Server struct {
	grpc.ServerStream
}

func (x *serviceInvalidSubscribe1Server) SendAndClose(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func (x *serviceInvalidSubscribe1Server) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Service_InvalidSubscribe2_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Data)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).InvalidSubscribe2(m, &serviceInvalidSubscribe2Server{stream})
}

type Service_InvalidSubscribe2Server interface {
	Send(*Data) error
	grpc.ServerStream
}

type serviceInvalidSubscribe2Server struct {
	grpc.ServerStream
}

func (x *serviceInvalidSubscribe2Server) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func _Service_InvalidSubscribe3_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ServiceServer).InvalidSubscribe3(&serviceInvalidSubscribe3Server{stream})
}

type Service_InvalidSubscribe3Server interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ServerStream
}

type serviceInvalidSubscribe3Server struct {
	grpc.ServerStream
}

func (x *serviceInvalidSubscribe3Server) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func (x *serviceInvalidSubscribe3Server) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Service_PubSub2_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ServiceServer).PubSub2(&servicePubSub2Server{stream})
}

type Service_PubSub2Server interface {
	Send(*Data) error
	Recv() (*Data, error)
	grpc.ServerStream
}

type servicePubSub2Server struct {
	grpc.ServerStream
}

func (x *servicePubSub2Server) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

func (x *servicePubSub2Server) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Service_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.Service",
	HandlerType: (*ServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Mutate1",
			Handler:    _Service_Mutate1_Handler,
		},
		{
			MethodName: "Mutate2",
			Handler:    _Service_Mutate2_Handler,
		},
		{
			MethodName: "Query1",
			Handler:    _Service_Query1_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Publish",
			Handler:       _Service_Publish_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _Service_Subscribe_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "PubSub1",
			Handler:       _Service_PubSub1_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "InvalidSubscribe1",
			Handler:       _Service_InvalidSubscribe1_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "InvalidSubscribe2",
			Handler:       _Service_InvalidSubscribe2_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InvalidSubscribe3",
			Handler:       _Service_InvalidSubscribe3_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "PubSub2",
			Handler:       _Service_PubSub2_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "pb/options.proto",
}

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type QueryClient interface {
	Query1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Query2(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Mutate1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error)
	Subscribe(ctx context.Context, in *Data, opts ...grpc.CallOption) (Query_SubscribeClient, error)
}

type queryClient struct {
	cc grpc.ClientConnInterface
}

func NewQueryClient(cc grpc.ClientConnInterface) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) Query1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Query/Query1", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Query2(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Query/Query2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Mutate1(ctx context.Context, in *Data, opts ...grpc.CallOption) (*Data, error) {
	out := new(Data)
	err := c.cc.Invoke(ctx, "/pb.Query/Mutate1", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Subscribe(ctx context.Context, in *Data, opts ...grpc.CallOption) (Query_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Query_serviceDesc.Streams[0], "/pb.Query/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &querySubscribeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_SubscribeClient interface {
	Recv() (*Data, error)
	grpc.ClientStream
}

type querySubscribeClient struct {
	grpc.ClientStream
}

func (x *querySubscribeClient) Recv() (*Data, error) {
	m := new(Data)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// QueryServer is the server API for Query service.
// All implementations must embed UnimplementedQueryServer
// for forward compatibility
type QueryServer interface {
	Query1(context.Context, *Data) (*Data, error)
	Query2(context.Context, *Data) (*Data, error)
	Mutate1(context.Context, *Data) (*Data, error)
	Subscribe(*Data, Query_SubscribeServer) error
	mustEmbedUnimplementedQueryServer()
}

// UnimplementedQueryServer must be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}

func (UnimplementedQueryServer) Query1(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query1 not implemented")
}
func (UnimplementedQueryServer) Query2(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Query2 not implemented")
}
func (UnimplementedQueryServer) Mutate1(context.Context, *Data) (*Data, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mutate1 not implemented")
}
func (UnimplementedQueryServer) Subscribe(*Data, Query_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}

// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to QueryServer will
// result in compilation errors.
type UnsafeQueryServer interface {
	mustEmbedUnimplementedQueryServer()
}

func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_Query1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Query1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Query/Query1",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Query1(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Query2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Query2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Query/Query2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Query2(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Mutate1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Data)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Mutate1(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Query/Mutate1",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Mutate1(ctx, req.(*Data))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Data)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).Subscribe(m, &querySubscribeServer{stream})
}

type Query_SubscribeServer interface {
	Send(*Data) error
	grpc.ServerStream
}

type querySubscribeServer struct {
	grpc.ServerStream
}

func (x *querySubscribeServer) Send(m *Data) error {
	return x.ServerStream.SendMsg(m)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Query1",
			Handler:    _Query_Query1_Handler,
		},
		{
			MethodName: "Query2",
			Handler:    _Query_Query2_Handler,
		},
		{
			MethodName: "Mutate1",
			Handler:    _Query_Mutate1_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _Query_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pb/options.proto",
}