api/generated/rpc/v1/executor_grpc.pb.go

//go:build !wasi

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: rpc/v1/executor.proto

package rpcv1

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.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	ExecutorService_ExecuteStream_FullMethodName = "/buildr.rpc.v1.ExecutorService/ExecuteStream"
)

// ExecutorServiceClient is the client API for ExecutorService 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 ExecutorServiceClient interface {
	ExecuteStream(ctx context.Context, opts ...grpc.CallOption) (ExecutorService_ExecuteStreamClient, error)
}

type executorServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewExecutorServiceClient(cc grpc.ClientConnInterface) ExecutorServiceClient {
	return &executorServiceClient{cc}
}

func (c *executorServiceClient) ExecuteStream(ctx context.Context, opts ...grpc.CallOption) (ExecutorService_ExecuteStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &ExecutorService_ServiceDesc.Streams[0], ExecutorService_ExecuteStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &executorServiceExecuteStreamClient{stream}
	return x, nil
}

type ExecutorService_ExecuteStreamClient interface {
	Send(*ExecutionClientMessage) error
	Recv() (*ExecutionServerMessage, error)
	grpc.ClientStream
}

type executorServiceExecuteStreamClient struct {
	grpc.ClientStream
}

func (x *executorServiceExecuteStreamClient) Send(m *ExecutionClientMessage) error {
	return x.ClientStream.SendMsg(m)
}

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

// ExecutorServiceServer is the server API for ExecutorService service.
// All implementations should embed UnimplementedExecutorServiceServer
// for forward compatibility
type ExecutorServiceServer interface {
	ExecuteStream(ExecutorService_ExecuteStreamServer) error
}

// UnimplementedExecutorServiceServer should be embedded to have forward compatible implementations.
type UnimplementedExecutorServiceServer struct {
}

func (UnimplementedExecutorServiceServer) ExecuteStream(ExecutorService_ExecuteStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method ExecuteStream not implemented")
}

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

func RegisterExecutorServiceServer(s grpc.ServiceRegistrar, srv ExecutorServiceServer) {
	s.RegisterService(&ExecutorService_ServiceDesc, srv)
}

func _ExecutorService_ExecuteStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ExecutorServiceServer).ExecuteStream(&executorServiceExecuteStreamServer{stream})
}

type ExecutorService_ExecuteStreamServer interface {
	Send(*ExecutionServerMessage) error
	Recv() (*ExecutionClientMessage, error)
	grpc.ServerStream
}

type executorServiceExecuteStreamServer struct {
	grpc.ServerStream
}

func (x *executorServiceExecuteStreamServer) Send(m *ExecutionServerMessage) error {
	return x.ServerStream.SendMsg(m)
}

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

// ExecutorService_ServiceDesc is the grpc.ServiceDesc for ExecutorService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ExecutorService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "buildr.rpc.v1.ExecutorService",
	HandlerType: (*ExecutorServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ExecuteStream",
			Handler:       _ExecutorService_ExecuteStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "rpc/v1/executor.proto",
}