ctpecs_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v5.29.3
// source: protos/ctpecs.proto

package ctpecs

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 (
	CTPd_PrepareForRun_FullMethodName = "/ctpd.CTPd/PrepareForRun"
	CTPd_RunLoad_FullMethodName       = "/ctpd.CTPd/RunLoad"
	CTPd_RunUnload_FullMethodName     = "/ctpd.CTPd/RunUnload"
	CTPd_RunStart_FullMethodName      = "/ctpd.CTPd/RunStart"
	CTPd_RunStatus_FullMethodName     = "/ctpd.CTPd/RunStatus"
	CTPd_RunList_FullMethodName       = "/ctpd.CTPd/RunList"
	CTPd_RunStop_FullMethodName       = "/ctpd.CTPd/RunStop"
	CTPd_RunConfig_FullMethodName     = "/ctpd.CTPd/RunConfig"
	CTPd_RunCleanup_FullMethodName    = "/ctpd.CTPd/RunCleanup"
	CTPd_TPCReset_FullMethodName      = "/ctpd.CTPd/TPCReset"
)

// CTPdClient is the client API for CTPd 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 CTPdClient interface {
	// global run:
	PrepareForRun(ctx context.Context, in *RunPrepareRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunLoad(ctx context.Context, in *RunLoadRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunUnload(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error)
	// stdalone and global runs:
	RunStart(ctx context.Context, in *RunStartRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunStatus(ctx context.Context, in *RunStatusRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error)
	RunStop(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunConfig(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error)
	RunCleanup(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error)
	TPCReset(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error)
}

type cTPdClient struct {
	cc grpc.ClientConnInterface
}

func NewCTPdClient(cc grpc.ClientConnInterface) CTPdClient {
	return &cTPdClient{cc}
}

func (c *cTPdClient) PrepareForRun(ctx context.Context, in *RunPrepareRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_PrepareForRun_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunLoad(ctx context.Context, in *RunLoadRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunLoad_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunUnload(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunUnload_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunStart(ctx context.Context, in *RunStartRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunStart_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunStatus(ctx context.Context, in *RunStatusRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunList(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunStop(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunStop_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunConfig(ctx context.Context, in *RunStopRequest, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunConfig_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) RunCleanup(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_RunCleanup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cTPdClient) TPCReset(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*RunReply, error) {
	out := new(RunReply)
	err := c.cc.Invoke(ctx, CTPd_TPCReset_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CTPdServer is the server API for CTPd service.
// All implementations should embed UnimplementedCTPdServer
// for forward compatibility
type CTPdServer interface {
	// global run:
	PrepareForRun(context.Context, *RunPrepareRequest) (*RunReply, error)
	RunLoad(context.Context, *RunLoadRequest) (*RunReply, error)
	RunUnload(context.Context, *RunStopRequest) (*RunReply, error)
	// stdalone and global runs:
	RunStart(context.Context, *RunStartRequest) (*RunReply, error)
	RunStatus(context.Context, *RunStatusRequest) (*RunReply, error)
	RunList(context.Context, *Empty) (*RunReply, error)
	RunStop(context.Context, *RunStopRequest) (*RunReply, error)
	RunConfig(context.Context, *RunStopRequest) (*RunReply, error)
	RunCleanup(context.Context, *Empty) (*RunReply, error)
	TPCReset(context.Context, *Empty) (*RunReply, error)
}

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

func (UnimplementedCTPdServer) PrepareForRun(context.Context, *RunPrepareRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrepareForRun not implemented")
}
func (UnimplementedCTPdServer) RunLoad(context.Context, *RunLoadRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunLoad not implemented")
}
func (UnimplementedCTPdServer) RunUnload(context.Context, *RunStopRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunUnload not implemented")
}
func (UnimplementedCTPdServer) RunStart(context.Context, *RunStartRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunStart not implemented")
}
func (UnimplementedCTPdServer) RunStatus(context.Context, *RunStatusRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunStatus not implemented")
}
func (UnimplementedCTPdServer) RunList(context.Context, *Empty) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunList not implemented")
}
func (UnimplementedCTPdServer) RunStop(context.Context, *RunStopRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunStop not implemented")
}
func (UnimplementedCTPdServer) RunConfig(context.Context, *RunStopRequest) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunConfig not implemented")
}
func (UnimplementedCTPdServer) RunCleanup(context.Context, *Empty) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCleanup not implemented")
}
func (UnimplementedCTPdServer) TPCReset(context.Context, *Empty) (*RunReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TPCReset not implemented")
}

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

func RegisterCTPdServer(s grpc.ServiceRegistrar, srv CTPdServer) {
	s.RegisterService(&CTPd_ServiceDesc, srv)
}

func _CTPd_PrepareForRun_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunPrepareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).PrepareForRun(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_PrepareForRun_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).PrepareForRun(ctx, req.(*RunPrepareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunLoad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunLoadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunLoad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunLoad_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunLoad(ctx, req.(*RunLoadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunUnload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunUnload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunUnload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunUnload(ctx, req.(*RunStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunStartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunStart(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunStart_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunStart(ctx, req.(*RunStartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunStatus(ctx, req.(*RunStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunList(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunStop(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunStop_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunStop(ctx, req.(*RunStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunStopRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunConfig(ctx, req.(*RunStopRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_RunCleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).RunCleanup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_RunCleanup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).RunCleanup(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _CTPd_TPCReset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CTPdServer).TPCReset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CTPd_TPCReset_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CTPdServer).TPCReset(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// CTPd_ServiceDesc is the grpc.ServiceDesc for CTPd service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CTPd_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "ctpd.CTPd",
	HandlerType: (*CTPdServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PrepareForRun",
			Handler:    _CTPd_PrepareForRun_Handler,
		},
		{
			MethodName: "RunLoad",
			Handler:    _CTPd_RunLoad_Handler,
		},
		{
			MethodName: "RunUnload",
			Handler:    _CTPd_RunUnload_Handler,
		},
		{
			MethodName: "RunStart",
			Handler:    _CTPd_RunStart_Handler,
		},
		{
			MethodName: "RunStatus",
			Handler:    _CTPd_RunStatus_Handler,
		},
		{
			MethodName: "RunList",
			Handler:    _CTPd_RunList_Handler,
		},
		{
			MethodName: "RunStop",
			Handler:    _CTPd_RunStop_Handler,
		},
		{
			MethodName: "RunConfig",
			Handler:    _CTPd_RunConfig_Handler,
		},
		{
			MethodName: "RunCleanup",
			Handler:    _CTPd_RunCleanup_Handler,
		},
		{
			MethodName: "TPCReset",
			Handler:    _CTPd_TPCReset_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/ctpecs.proto",
}