projections_grpc.pb.go

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

package projections

import (
	context "context"
	shared "github.com/EventStore/EventStore-Client-Go/v4/protos/shared"
	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.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// ProjectionsClient is the client API for Projections 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 ProjectionsClient interface {
	Create(ctx context.Context, in *CreateReq, opts ...grpc.CallOption) (*CreateResp, error)
	Update(ctx context.Context, in *UpdateReq, opts ...grpc.CallOption) (*UpdateResp, error)
	Delete(ctx context.Context, in *DeleteReq, opts ...grpc.CallOption) (*DeleteResp, error)
	Statistics(ctx context.Context, in *StatisticsReq, opts ...grpc.CallOption) (Projections_StatisticsClient, error)
	Disable(ctx context.Context, in *DisableReq, opts ...grpc.CallOption) (*DisableResp, error)
	Enable(ctx context.Context, in *EnableReq, opts ...grpc.CallOption) (*EnableResp, error)
	Reset(ctx context.Context, in *ResetReq, opts ...grpc.CallOption) (*ResetResp, error)
	State(ctx context.Context, in *StateReq, opts ...grpc.CallOption) (*StateResp, error)
	Result(ctx context.Context, in *ResultReq, opts ...grpc.CallOption) (*ResultResp, error)
	RestartSubsystem(ctx context.Context, in *shared.Empty, opts ...grpc.CallOption) (*shared.Empty, error)
}

type projectionsClient struct {
	cc grpc.ClientConnInterface
}

func NewProjectionsClient(cc grpc.ClientConnInterface) ProjectionsClient {
	return &projectionsClient{cc}
}

func (c *projectionsClient) Create(ctx context.Context, in *CreateReq, opts ...grpc.CallOption) (*CreateResp, error) {
	out := new(CreateResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Update(ctx context.Context, in *UpdateReq, opts ...grpc.CallOption) (*UpdateResp, error) {
	out := new(UpdateResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Delete(ctx context.Context, in *DeleteReq, opts ...grpc.CallOption) (*DeleteResp, error) {
	out := new(DeleteResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Statistics(ctx context.Context, in *StatisticsReq, opts ...grpc.CallOption) (Projections_StatisticsClient, error) {
	stream, err := c.cc.NewStream(ctx, &Projections_ServiceDesc.Streams[0], "/event_store.client.projections.Projections/Statistics", opts...)
	if err != nil {
		return nil, err
	}
	x := &projectionsStatisticsClient{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 Projections_StatisticsClient interface {
	Recv() (*StatisticsResp, error)
	grpc.ClientStream
}

type projectionsStatisticsClient struct {
	grpc.ClientStream
}

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

func (c *projectionsClient) Disable(ctx context.Context, in *DisableReq, opts ...grpc.CallOption) (*DisableResp, error) {
	out := new(DisableResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Disable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Enable(ctx context.Context, in *EnableReq, opts ...grpc.CallOption) (*EnableResp, error) {
	out := new(EnableResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Enable", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Reset(ctx context.Context, in *ResetReq, opts ...grpc.CallOption) (*ResetResp, error) {
	out := new(ResetResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Reset", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) State(ctx context.Context, in *StateReq, opts ...grpc.CallOption) (*StateResp, error) {
	out := new(StateResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/State", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) Result(ctx context.Context, in *ResultReq, opts ...grpc.CallOption) (*ResultResp, error) {
	out := new(ResultResp)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/Result", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectionsClient) RestartSubsystem(ctx context.Context, in *shared.Empty, opts ...grpc.CallOption) (*shared.Empty, error) {
	out := new(shared.Empty)
	err := c.cc.Invoke(ctx, "/event_store.client.projections.Projections/RestartSubsystem", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProjectionsServer is the server API for Projections service.
// All implementations must embed UnimplementedProjectionsServer
// for forward compatibility
type ProjectionsServer interface {
	Create(context.Context, *CreateReq) (*CreateResp, error)
	Update(context.Context, *UpdateReq) (*UpdateResp, error)
	Delete(context.Context, *DeleteReq) (*DeleteResp, error)
	Statistics(*StatisticsReq, Projections_StatisticsServer) error
	Disable(context.Context, *DisableReq) (*DisableResp, error)
	Enable(context.Context, *EnableReq) (*EnableResp, error)
	Reset(context.Context, *ResetReq) (*ResetResp, error)
	State(context.Context, *StateReq) (*StateResp, error)
	Result(context.Context, *ResultReq) (*ResultResp, error)
	RestartSubsystem(context.Context, *shared.Empty) (*shared.Empty, error)
	mustEmbedUnimplementedProjectionsServer()
}

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

func (UnimplementedProjectionsServer) Create(context.Context, *CreateReq) (*CreateResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedProjectionsServer) Update(context.Context, *UpdateReq) (*UpdateResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (UnimplementedProjectionsServer) Delete(context.Context, *DeleteReq) (*DeleteResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedProjectionsServer) Statistics(*StatisticsReq, Projections_StatisticsServer) error {
	return status.Errorf(codes.Unimplemented, "method Statistics not implemented")
}
func (UnimplementedProjectionsServer) Disable(context.Context, *DisableReq) (*DisableResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Disable not implemented")
}
func (UnimplementedProjectionsServer) Enable(context.Context, *EnableReq) (*EnableResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Enable not implemented")
}
func (UnimplementedProjectionsServer) Reset(context.Context, *ResetReq) (*ResetResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Reset not implemented")
}
func (UnimplementedProjectionsServer) State(context.Context, *StateReq) (*StateResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method State not implemented")
}
func (UnimplementedProjectionsServer) Result(context.Context, *ResultReq) (*ResultResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Result not implemented")
}
func (UnimplementedProjectionsServer) RestartSubsystem(context.Context, *shared.Empty) (*shared.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartSubsystem not implemented")
}
func (UnimplementedProjectionsServer) mustEmbedUnimplementedProjectionsServer() {}

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

func RegisterProjectionsServer(s grpc.ServiceRegistrar, srv ProjectionsServer) {
	s.RegisterService(&Projections_ServiceDesc, srv)
}

func _Projections_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Create(ctx, req.(*CreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Update(ctx, req.(*UpdateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Delete(ctx, req.(*DeleteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Statistics_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StatisticsReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProjectionsServer).Statistics(m, &projectionsStatisticsServer{stream})
}

type Projections_StatisticsServer interface {
	Send(*StatisticsResp) error
	grpc.ServerStream
}

type projectionsStatisticsServer struct {
	grpc.ServerStream
}

func (x *projectionsStatisticsServer) Send(m *StatisticsResp) error {
	return x.ServerStream.SendMsg(m)
}

func _Projections_Disable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisableReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Disable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Disable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Disable(ctx, req.(*DisableReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Enable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnableReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Enable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Enable",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Enable(ctx, req.(*EnableReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Reset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Reset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Reset",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Reset(ctx, req.(*ResetReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_State_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).State(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/State",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).State(ctx, req.(*StateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_Result_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResultReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).Result(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/Result",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).Result(ctx, req.(*ResultReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projections_RestartSubsystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(shared.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectionsServer).RestartSubsystem(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_store.client.projections.Projections/RestartSubsystem",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectionsServer).RestartSubsystem(ctx, req.(*shared.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// Projections_ServiceDesc is the grpc.ServiceDesc for Projections service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Projections_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "event_store.client.projections.Projections",
	HandlerType: (*ProjectionsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _Projections_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _Projections_Update_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _Projections_Delete_Handler,
		},
		{
			MethodName: "Disable",
			Handler:    _Projections_Disable_Handler,
		},
		{
			MethodName: "Enable",
			Handler:    _Projections_Enable_Handler,
		},
		{
			MethodName: "Reset",
			Handler:    _Projections_Reset_Handler,
		},
		{
			MethodName: "State",
			Handler:    _Projections_State_Handler,
		},
		{
			MethodName: "Result",
			Handler:    _Projections_Result_Handler,
		},
		{
			MethodName: "RestartSubsystem",
			Handler:    _Projections_RestartSubsystem_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Statistics",
			Handler:       _Projections_Statistics_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "projections.proto",
}