hermes_grpc.pb.go

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

package proto

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.SupportPackageIsVersion6

// HermesClient is the client API for Hermes 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 HermesClient interface {
	EventBuff(ctx context.Context, opts ...grpc.CallOption) (Hermes_EventBuffClient, error)
}

type hermesClient struct {
	cc grpc.ClientConnInterface
}

func NewHermesClient(cc grpc.ClientConnInterface) HermesClient {
	return &hermesClient{cc}
}

func (c *hermesClient) EventBuff(ctx context.Context, opts ...grpc.CallOption) (Hermes_EventBuffClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Hermes_serviceDesc.Streams[0], "/proto.Hermes/EventBuff", opts...)
	if err != nil {
		return nil, err
	}
	x := &hermesEventBuffClient{stream}
	return x, nil
}

type Hermes_EventBuffClient interface {
	Send(*Event) error
	Recv() (*Event, error)
	grpc.ClientStream
}

type hermesEventBuffClient struct {
	grpc.ClientStream
}

func (x *hermesEventBuffClient) Send(m *Event) error {
	return x.ClientStream.SendMsg(m)
}

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

// HermesServer is the server API for Hermes service.
// All implementations must embed UnimplementedHermesServer
// for forward compatibility
type HermesServer interface {
	EventBuff(Hermes_EventBuffServer) error
	mustEmbedUnimplementedHermesServer()
}

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

func (*UnimplementedHermesServer) EventBuff(Hermes_EventBuffServer) error {
	return status.Errorf(codes.Unimplemented, "method EventBuff not implemented")
}
func (*UnimplementedHermesServer) mustEmbedUnimplementedHermesServer() {}

func RegisterHermesServer(s *grpc.Server, srv HermesServer) {
	s.RegisterService(&_Hermes_serviceDesc, srv)
}

func _Hermes_EventBuff_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(HermesServer).EventBuff(&hermesEventBuffServer{stream})
}

type Hermes_EventBuffServer interface {
	Send(*Event) error
	Recv() (*Event, error)
	grpc.ServerStream
}

type hermesEventBuffServer struct {
	grpc.ServerStream
}

func (x *hermesEventBuffServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

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

var _Hermes_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.Hermes",
	HandlerType: (*HermesServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "EventBuff",
			Handler:       _Hermes_EventBuff_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "hermes.proto",
}