//Generated by gRPC Go plugin
//If you make any local changes, they will be lost
//source: monster_test

package Example

import (
	context "context"
	flatbuffers "github.com/google/flatbuffers/go"
	grpc "google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// Client API for MonsterStorage service
type MonsterStorageClient interface {
	Store(ctx context.Context, in *flatbuffers.Builder,
		opts ...grpc.CallOption) (*Stat, error)
	Retrieve(ctx context.Context, in *flatbuffers.Builder,
		opts ...grpc.CallOption) (MonsterStorage_RetrieveClient, error)
	GetMaxHitPoint(ctx context.Context,
		opts ...grpc.CallOption) (MonsterStorage_GetMaxHitPointClient, error)
	GetMinMaxHitPoints(ctx context.Context,
		opts ...grpc.CallOption) (MonsterStorage_GetMinMaxHitPointsClient, error)
}

type monsterStorageClient struct {
	cc grpc.ClientConnInterface
}

func NewMonsterStorageClient(cc grpc.ClientConnInterface) MonsterStorageClient {
	return &monsterStorageClient{cc}
}

func (c *monsterStorageClient) Store(ctx context.Context, in *flatbuffers.Builder,
	opts ...grpc.CallOption) (*Stat, error) {
	out := new(Stat)
	err := c.cc.Invoke(ctx, "/MyGame.Example.MonsterStorage/Store", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *monsterStorageClient) Retrieve(ctx context.Context, in *flatbuffers.Builder,
	opts ...grpc.CallOption) (MonsterStorage_RetrieveClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MonsterStorage_serviceDesc.Streams[0], "/MyGame.Example.MonsterStorage/Retrieve", opts...)
	if err != nil {
		return nil, err
	}
	x := &monsterStorageRetrieveClient{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 MonsterStorage_RetrieveClient interface {
	Recv() (*Monster, error)
	grpc.ClientStream
}

type monsterStorageRetrieveClient struct {
	grpc.ClientStream
}

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

func (c *monsterStorageClient) GetMaxHitPoint(ctx context.Context,
	opts ...grpc.CallOption) (MonsterStorage_GetMaxHitPointClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MonsterStorage_serviceDesc.Streams[1], "/MyGame.Example.MonsterStorage/GetMaxHitPoint", opts...)
	if err != nil {
		return nil, err
	}
	x := &monsterStorageGetMaxHitPointClient{stream}
	return x, nil
}

type MonsterStorage_GetMaxHitPointClient interface {
	Send(*flatbuffers.Builder) error
	CloseAndRecv() (*Stat, error)
	grpc.ClientStream
}

type monsterStorageGetMaxHitPointClient struct {
	grpc.ClientStream
}

func (x *monsterStorageGetMaxHitPointClient) Send(m *flatbuffers.Builder) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *monsterStorageClient) GetMinMaxHitPoints(ctx context.Context,
	opts ...grpc.CallOption) (MonsterStorage_GetMinMaxHitPointsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_MonsterStorage_serviceDesc.Streams[2], "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints", opts...)
	if err != nil {
		return nil, err
	}
	x := &monsterStorageGetMinMaxHitPointsClient{stream}
	return x, nil
}

type MonsterStorage_GetMinMaxHitPointsClient interface {
	Send(*flatbuffers.Builder) error
	Recv() (*Stat, error)
	grpc.ClientStream
}

type monsterStorageGetMinMaxHitPointsClient struct {
	grpc.ClientStream
}

func (x *monsterStorageGetMinMaxHitPointsClient) Send(m *flatbuffers.Builder) error {
	return x.ClientStream.SendMsg(m)
}

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

// Server API for MonsterStorage service
type MonsterStorageServer interface {
	Store(context.Context, *Monster) (*flatbuffers.Builder, error)
	Retrieve(*Stat, MonsterStorage_RetrieveServer) error
	GetMaxHitPoint(MonsterStorage_GetMaxHitPointServer) error
	GetMinMaxHitPoints(MonsterStorage_GetMinMaxHitPointsServer) error
	mustEmbedUnimplementedMonsterStorageServer()
}

type UnimplementedMonsterStorageServer struct {
}

func (UnimplementedMonsterStorageServer) Store(context.Context, *Monster) (*flatbuffers.Builder, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Store not implemented")
}

func (UnimplementedMonsterStorageServer) Retrieve(*Stat, MonsterStorage_RetrieveServer) error {
	return status.Errorf(codes.Unimplemented, "method Retrieve not implemented")
}

func (UnimplementedMonsterStorageServer) GetMaxHitPoint(MonsterStorage_GetMaxHitPointServer) error {
	return status.Errorf(codes.Unimplemented, "method GetMaxHitPoint not implemented")
}

func (UnimplementedMonsterStorageServer) GetMinMaxHitPoints(MonsterStorage_GetMinMaxHitPointsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetMinMaxHitPoints not implemented")
}

func (UnimplementedMonsterStorageServer) mustEmbedUnimplementedMonsterStorageServer() {}

type UnsafeMonsterStorageServer interface {
	mustEmbedUnimplementedMonsterStorageServer()
}

func RegisterMonsterStorageServer(s grpc.ServiceRegistrar, srv MonsterStorageServer) {
	s.RegisterService(&_MonsterStorage_serviceDesc, srv)
}

func _MonsterStorage_Store_Handler(srv interface{}, ctx context.Context,
	dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Monster)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MonsterStorageServer).Store(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/MyGame.Example.MonsterStorage/Store",
	}

	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MonsterStorageServer).Store(ctx, req.(*Monster))
	}
	return interceptor(ctx, in, info, handler)
}
func _MonsterStorage_Retrieve_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Stat)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MonsterStorageServer).Retrieve(m, &monsterStorageRetrieveServer{stream})
}

type MonsterStorage_RetrieveServer interface {
	Send(*flatbuffers.Builder) error
	grpc.ServerStream
}

type monsterStorageRetrieveServer struct {
	grpc.ServerStream
}

func (x *monsterStorageRetrieveServer) Send(m *flatbuffers.Builder) error {
	return x.ServerStream.SendMsg(m)
}

func _MonsterStorage_GetMaxHitPoint_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonsterStorageServer).GetMaxHitPoint(&monsterStorageGetMaxHitPointServer{stream})
}

type MonsterStorage_GetMaxHitPointServer interface {
	Recv() (*Monster, error)
	SendAndClose(*flatbuffers.Builder) error
	grpc.ServerStream
}

type monsterStorageGetMaxHitPointServer struct {
	grpc.ServerStream
}

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

func (x *monsterStorageGetMaxHitPointServer) SendAndClose(m *flatbuffers.Builder) error {
	return x.ServerStream.SendMsg(m)
}

func _MonsterStorage_GetMinMaxHitPoints_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MonsterStorageServer).GetMinMaxHitPoints(&monsterStorageGetMinMaxHitPointsServer{stream})
}

type MonsterStorage_GetMinMaxHitPointsServer interface {
	Send(*flatbuffers.Builder) error
	Recv() (*Monster, error)
	grpc.ServerStream
}

type monsterStorageGetMinMaxHitPointsServer struct {
	grpc.ServerStream
}

func (x *monsterStorageGetMinMaxHitPointsServer) Send(m *flatbuffers.Builder) error {
	return x.ServerStream.SendMsg(m)
}

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

var _MonsterStorage_serviceDesc = grpc.ServiceDesc{
	ServiceName: "MyGame.Example.MonsterStorage",
	HandlerType: (*MonsterStorageServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Store",
			Handler:    _MonsterStorage_Store_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Retrieve",
			Handler:       _MonsterStorage_Retrieve_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetMaxHitPoint",
			Handler:       _MonsterStorage_GetMaxHitPoint_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetMinMaxHitPoints",
			Handler:       _MonsterStorage_GetMinMaxHitPoints_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
}
