protobuf/gamelang-jeopardy/gamelang-jeopardy_grpc.pb.go

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

package jeopardypb

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

// EventServiceClient is the client API for EventService 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 EventServiceClient interface {
	Inform(ctx context.Context, in *Event, opts ...grpc.CallOption) (*Event, error)
}

type eventServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewEventServiceClient(cc grpc.ClientConnInterface) EventServiceClient {
	return &eventServiceClient{cc}
}

func (c *eventServiceClient) Inform(ctx context.Context, in *Event, opts ...grpc.CallOption) (*Event, error) {
	out := new(Event)
	err := c.cc.Invoke(ctx, "/gamelang.EventService/Inform", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EventServiceServer is the server API for EventService service.
// All implementations must embed UnimplementedEventServiceServer
// for forward compatibility
type EventServiceServer interface {
	Inform(context.Context, *Event) (*Event, error)
	mustEmbedUnimplementedEventServiceServer()
}

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

func (UnimplementedEventServiceServer) Inform(context.Context, *Event) (*Event, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Inform not implemented")
}
func (UnimplementedEventServiceServer) mustEmbedUnimplementedEventServiceServer() {}

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

func RegisterEventServiceServer(s grpc.ServiceRegistrar, srv EventServiceServer) {
	s.RegisterService(&_EventService_serviceDesc, srv)
}

func _EventService_Inform_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Event)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EventServiceServer).Inform(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.EventService/Inform",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EventServiceServer).Inform(ctx, req.(*Event))
	}
	return interceptor(ctx, in, info, handler)
}

var _EventService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gamelang.EventService",
	HandlerType: (*EventServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Inform",
			Handler:    _EventService_Inform_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gamelang-jeopardy.proto",
}

// JeopardyServiceClient is the client API for JeopardyService 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 JeopardyServiceClient interface {
	CreateJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error)
	UpdateJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error)
	DeleteJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error)
	GetJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error)
	ListJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (JeopardyService_ListJeopardyClient, error)
	CreateRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error)
	UpdateRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error)
	DeleteRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error)
	GetRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error)
	ListRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (JeopardyService_ListRoundClient, error)
	CreateChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error)
	UpdateChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error)
	DeleteChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error)
	GetChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error)
	ListChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (JeopardyService_ListChallengeClient, error)
}

type jeopardyServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewJeopardyServiceClient(cc grpc.ClientConnInterface) JeopardyServiceClient {
	return &jeopardyServiceClient{cc}
}

func (c *jeopardyServiceClient) CreateJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error) {
	out := new(Jeopardy)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/CreateJeopardy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) UpdateJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error) {
	out := new(Jeopardy)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/UpdateJeopardy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) DeleteJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error) {
	out := new(Jeopardy)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/DeleteJeopardy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) GetJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (*Jeopardy, error) {
	out := new(Jeopardy)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/GetJeopardy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) ListJeopardy(ctx context.Context, in *Jeopardy, opts ...grpc.CallOption) (JeopardyService_ListJeopardyClient, error) {
	stream, err := c.cc.NewStream(ctx, &_JeopardyService_serviceDesc.Streams[0], "/gamelang.JeopardyService/ListJeopardy", opts...)
	if err != nil {
		return nil, err
	}
	x := &jeopardyServiceListJeopardyClient{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 JeopardyService_ListJeopardyClient interface {
	Recv() (*Jeopardy, error)
	grpc.ClientStream
}

type jeopardyServiceListJeopardyClient struct {
	grpc.ClientStream
}

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

func (c *jeopardyServiceClient) CreateRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error) {
	out := new(Round)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/CreateRound", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) UpdateRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error) {
	out := new(Round)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/UpdateRound", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) DeleteRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error) {
	out := new(Round)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/DeleteRound", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) GetRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (*Round, error) {
	out := new(Round)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/GetRound", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) ListRound(ctx context.Context, in *Round, opts ...grpc.CallOption) (JeopardyService_ListRoundClient, error) {
	stream, err := c.cc.NewStream(ctx, &_JeopardyService_serviceDesc.Streams[1], "/gamelang.JeopardyService/ListRound", opts...)
	if err != nil {
		return nil, err
	}
	x := &jeopardyServiceListRoundClient{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 JeopardyService_ListRoundClient interface {
	Recv() (*Round, error)
	grpc.ClientStream
}

type jeopardyServiceListRoundClient struct {
	grpc.ClientStream
}

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

func (c *jeopardyServiceClient) CreateChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error) {
	out := new(Challenge)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/CreateChallenge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) UpdateChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error) {
	out := new(Challenge)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/UpdateChallenge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) DeleteChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error) {
	out := new(Challenge)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/DeleteChallenge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) GetChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (*Challenge, error) {
	out := new(Challenge)
	err := c.cc.Invoke(ctx, "/gamelang.JeopardyService/GetChallenge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jeopardyServiceClient) ListChallenge(ctx context.Context, in *Challenge, opts ...grpc.CallOption) (JeopardyService_ListChallengeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_JeopardyService_serviceDesc.Streams[2], "/gamelang.JeopardyService/ListChallenge", opts...)
	if err != nil {
		return nil, err
	}
	x := &jeopardyServiceListChallengeClient{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 JeopardyService_ListChallengeClient interface {
	Recv() (*Challenge, error)
	grpc.ClientStream
}

type jeopardyServiceListChallengeClient struct {
	grpc.ClientStream
}

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

// JeopardyServiceServer is the server API for JeopardyService service.
// All implementations must embed UnimplementedJeopardyServiceServer
// for forward compatibility
type JeopardyServiceServer interface {
	CreateJeopardy(context.Context, *Jeopardy) (*Jeopardy, error)
	UpdateJeopardy(context.Context, *Jeopardy) (*Jeopardy, error)
	DeleteJeopardy(context.Context, *Jeopardy) (*Jeopardy, error)
	GetJeopardy(context.Context, *Jeopardy) (*Jeopardy, error)
	ListJeopardy(*Jeopardy, JeopardyService_ListJeopardyServer) error
	CreateRound(context.Context, *Round) (*Round, error)
	UpdateRound(context.Context, *Round) (*Round, error)
	DeleteRound(context.Context, *Round) (*Round, error)
	GetRound(context.Context, *Round) (*Round, error)
	ListRound(*Round, JeopardyService_ListRoundServer) error
	CreateChallenge(context.Context, *Challenge) (*Challenge, error)
	UpdateChallenge(context.Context, *Challenge) (*Challenge, error)
	DeleteChallenge(context.Context, *Challenge) (*Challenge, error)
	GetChallenge(context.Context, *Challenge) (*Challenge, error)
	ListChallenge(*Challenge, JeopardyService_ListChallengeServer) error
	mustEmbedUnimplementedJeopardyServiceServer()
}

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

func (UnimplementedJeopardyServiceServer) CreateJeopardy(context.Context, *Jeopardy) (*Jeopardy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateJeopardy not implemented")
}
func (UnimplementedJeopardyServiceServer) UpdateJeopardy(context.Context, *Jeopardy) (*Jeopardy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateJeopardy not implemented")
}
func (UnimplementedJeopardyServiceServer) DeleteJeopardy(context.Context, *Jeopardy) (*Jeopardy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteJeopardy not implemented")
}
func (UnimplementedJeopardyServiceServer) GetJeopardy(context.Context, *Jeopardy) (*Jeopardy, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJeopardy not implemented")
}
func (UnimplementedJeopardyServiceServer) ListJeopardy(*Jeopardy, JeopardyService_ListJeopardyServer) error {
	return status.Errorf(codes.Unimplemented, "method ListJeopardy not implemented")
}
func (UnimplementedJeopardyServiceServer) CreateRound(context.Context, *Round) (*Round, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateRound not implemented")
}
func (UnimplementedJeopardyServiceServer) UpdateRound(context.Context, *Round) (*Round, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRound not implemented")
}
func (UnimplementedJeopardyServiceServer) DeleteRound(context.Context, *Round) (*Round, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRound not implemented")
}
func (UnimplementedJeopardyServiceServer) GetRound(context.Context, *Round) (*Round, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRound not implemented")
}
func (UnimplementedJeopardyServiceServer) ListRound(*Round, JeopardyService_ListRoundServer) error {
	return status.Errorf(codes.Unimplemented, "method ListRound not implemented")
}
func (UnimplementedJeopardyServiceServer) CreateChallenge(context.Context, *Challenge) (*Challenge, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateChallenge not implemented")
}
func (UnimplementedJeopardyServiceServer) UpdateChallenge(context.Context, *Challenge) (*Challenge, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateChallenge not implemented")
}
func (UnimplementedJeopardyServiceServer) DeleteChallenge(context.Context, *Challenge) (*Challenge, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteChallenge not implemented")
}
func (UnimplementedJeopardyServiceServer) GetChallenge(context.Context, *Challenge) (*Challenge, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetChallenge not implemented")
}
func (UnimplementedJeopardyServiceServer) ListChallenge(*Challenge, JeopardyService_ListChallengeServer) error {
	return status.Errorf(codes.Unimplemented, "method ListChallenge not implemented")
}
func (UnimplementedJeopardyServiceServer) mustEmbedUnimplementedJeopardyServiceServer() {}

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

func RegisterJeopardyServiceServer(s grpc.ServiceRegistrar, srv JeopardyServiceServer) {
	s.RegisterService(&_JeopardyService_serviceDesc, srv)
}

func _JeopardyService_CreateJeopardy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Jeopardy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).CreateJeopardy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/CreateJeopardy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).CreateJeopardy(ctx, req.(*Jeopardy))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_UpdateJeopardy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Jeopardy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).UpdateJeopardy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/UpdateJeopardy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).UpdateJeopardy(ctx, req.(*Jeopardy))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_DeleteJeopardy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Jeopardy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).DeleteJeopardy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/DeleteJeopardy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).DeleteJeopardy(ctx, req.(*Jeopardy))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_GetJeopardy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Jeopardy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).GetJeopardy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/GetJeopardy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).GetJeopardy(ctx, req.(*Jeopardy))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_ListJeopardy_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Jeopardy)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(JeopardyServiceServer).ListJeopardy(m, &jeopardyServiceListJeopardyServer{stream})
}

type JeopardyService_ListJeopardyServer interface {
	Send(*Jeopardy) error
	grpc.ServerStream
}

type jeopardyServiceListJeopardyServer struct {
	grpc.ServerStream
}

func (x *jeopardyServiceListJeopardyServer) Send(m *Jeopardy) error {
	return x.ServerStream.SendMsg(m)
}

func _JeopardyService_CreateRound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Round)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).CreateRound(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/CreateRound",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).CreateRound(ctx, req.(*Round))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_UpdateRound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Round)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).UpdateRound(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/UpdateRound",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).UpdateRound(ctx, req.(*Round))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_DeleteRound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Round)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).DeleteRound(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/DeleteRound",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).DeleteRound(ctx, req.(*Round))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_GetRound_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Round)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).GetRound(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/GetRound",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).GetRound(ctx, req.(*Round))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_ListRound_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Round)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(JeopardyServiceServer).ListRound(m, &jeopardyServiceListRoundServer{stream})
}

type JeopardyService_ListRoundServer interface {
	Send(*Round) error
	grpc.ServerStream
}

type jeopardyServiceListRoundServer struct {
	grpc.ServerStream
}

func (x *jeopardyServiceListRoundServer) Send(m *Round) error {
	return x.ServerStream.SendMsg(m)
}

func _JeopardyService_CreateChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Challenge)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).CreateChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/CreateChallenge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).CreateChallenge(ctx, req.(*Challenge))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_UpdateChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Challenge)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).UpdateChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/UpdateChallenge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).UpdateChallenge(ctx, req.(*Challenge))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_DeleteChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Challenge)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).DeleteChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/DeleteChallenge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).DeleteChallenge(ctx, req.(*Challenge))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_GetChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Challenge)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JeopardyServiceServer).GetChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gamelang.JeopardyService/GetChallenge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JeopardyServiceServer).GetChallenge(ctx, req.(*Challenge))
	}
	return interceptor(ctx, in, info, handler)
}

func _JeopardyService_ListChallenge_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Challenge)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(JeopardyServiceServer).ListChallenge(m, &jeopardyServiceListChallengeServer{stream})
}

type JeopardyService_ListChallengeServer interface {
	Send(*Challenge) error
	grpc.ServerStream
}

type jeopardyServiceListChallengeServer struct {
	grpc.ServerStream
}

func (x *jeopardyServiceListChallengeServer) Send(m *Challenge) error {
	return x.ServerStream.SendMsg(m)
}

var _JeopardyService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gamelang.JeopardyService",
	HandlerType: (*JeopardyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateJeopardy",
			Handler:    _JeopardyService_CreateJeopardy_Handler,
		},
		{
			MethodName: "UpdateJeopardy",
			Handler:    _JeopardyService_UpdateJeopardy_Handler,
		},
		{
			MethodName: "DeleteJeopardy",
			Handler:    _JeopardyService_DeleteJeopardy_Handler,
		},
		{
			MethodName: "GetJeopardy",
			Handler:    _JeopardyService_GetJeopardy_Handler,
		},
		{
			MethodName: "CreateRound",
			Handler:    _JeopardyService_CreateRound_Handler,
		},
		{
			MethodName: "UpdateRound",
			Handler:    _JeopardyService_UpdateRound_Handler,
		},
		{
			MethodName: "DeleteRound",
			Handler:    _JeopardyService_DeleteRound_Handler,
		},
		{
			MethodName: "GetRound",
			Handler:    _JeopardyService_GetRound_Handler,
		},
		{
			MethodName: "CreateChallenge",
			Handler:    _JeopardyService_CreateChallenge_Handler,
		},
		{
			MethodName: "UpdateChallenge",
			Handler:    _JeopardyService_UpdateChallenge_Handler,
		},
		{
			MethodName: "DeleteChallenge",
			Handler:    _JeopardyService_DeleteChallenge_Handler,
		},
		{
			MethodName: "GetChallenge",
			Handler:    _JeopardyService_GetChallenge_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListJeopardy",
			Handler:       _JeopardyService_ListJeopardy_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListRound",
			Handler:       _JeopardyService_ListRound_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListChallenge",
			Handler:       _JeopardyService_ListChallenge_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "gamelang-jeopardy.proto",
}