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"
)
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
}
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,
},
},
}