// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.19.4
// source: ultipa.proto

package ultipa

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

// UltipaRpcsClient is the client API for UltipaRpcs 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 UltipaRpcsClient interface {
	//1.Sends a greeting
	SayHello(ctx context.Context, in *HelloUltipaRequest, opts ...grpc.CallOption) (*HelloUltipaReply, error)
	//2.uql
	Uql(ctx context.Context, in *UqlRequest, opts ...grpc.CallOption) (UltipaRpcs_UqlClient, error)
	//3.插入点
	InsertNodes(ctx context.Context, in *InsertNodesRequest, opts ...grpc.CallOption) (*InsertNodesReply, error)
	//4.插入边
	InsertEdges(ctx context.Context, in *InsertEdgesRequest, opts ...grpc.CallOption) (*InsertEdgesReply, error)
}

type ultipaRpcsClient struct {
	cc grpc.ClientConnInterface
}

func NewUltipaRpcsClient(cc grpc.ClientConnInterface) UltipaRpcsClient {
	return &ultipaRpcsClient{cc}
}

func (c *ultipaRpcsClient) SayHello(ctx context.Context, in *HelloUltipaRequest, opts ...grpc.CallOption) (*HelloUltipaReply, error) {
	out := new(HelloUltipaReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaRpcs/SayHello", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaRpcsClient) Uql(ctx context.Context, in *UqlRequest, opts ...grpc.CallOption) (UltipaRpcs_UqlClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaRpcs_ServiceDesc.Streams[0], "/ultipa.UltipaRpcs/Uql", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaRpcsUqlClient{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 UltipaRpcs_UqlClient interface {
	Recv() (*UqlReply, error)
	grpc.ClientStream
}

type ultipaRpcsUqlClient struct {
	grpc.ClientStream
}

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

func (c *ultipaRpcsClient) InsertNodes(ctx context.Context, in *InsertNodesRequest, opts ...grpc.CallOption) (*InsertNodesReply, error) {
	out := new(InsertNodesReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaRpcs/InsertNodes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaRpcsClient) InsertEdges(ctx context.Context, in *InsertEdgesRequest, opts ...grpc.CallOption) (*InsertEdgesReply, error) {
	out := new(InsertEdgesReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaRpcs/InsertEdges", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// UltipaRpcsServer is the server API for UltipaRpcs service.
// All implementations must embed UnimplementedUltipaRpcsServer
// for forward compatibility
type UltipaRpcsServer interface {
	//1.Sends a greeting
	SayHello(context.Context, *HelloUltipaRequest) (*HelloUltipaReply, error)
	//2.uql
	Uql(*UqlRequest, UltipaRpcs_UqlServer) error
	//3.插入点
	InsertNodes(context.Context, *InsertNodesRequest) (*InsertNodesReply, error)
	//4.插入边
	InsertEdges(context.Context, *InsertEdgesRequest) (*InsertEdgesReply, error)
	mustEmbedUnimplementedUltipaRpcsServer()
}

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

func (UnimplementedUltipaRpcsServer) SayHello(context.Context, *HelloUltipaRequest) (*HelloUltipaReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}
func (UnimplementedUltipaRpcsServer) Uql(*UqlRequest, UltipaRpcs_UqlServer) error {
	return status.Errorf(codes.Unimplemented, "method Uql not implemented")
}
func (UnimplementedUltipaRpcsServer) InsertNodes(context.Context, *InsertNodesRequest) (*InsertNodesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertNodes not implemented")
}
func (UnimplementedUltipaRpcsServer) InsertEdges(context.Context, *InsertEdgesRequest) (*InsertEdgesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InsertEdges not implemented")
}
func (UnimplementedUltipaRpcsServer) mustEmbedUnimplementedUltipaRpcsServer() {}

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

func RegisterUltipaRpcsServer(s grpc.ServiceRegistrar, srv UltipaRpcsServer) {
	s.RegisterService(&UltipaRpcs_ServiceDesc, srv)
}

func _UltipaRpcs_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HelloUltipaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaRpcsServer).SayHello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaRpcs/SayHello",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaRpcsServer).SayHello(ctx, req.(*HelloUltipaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaRpcs_Uql_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UqlRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UltipaRpcsServer).Uql(m, &ultipaRpcsUqlServer{stream})
}

type UltipaRpcs_UqlServer interface {
	Send(*UqlReply) error
	grpc.ServerStream
}

type ultipaRpcsUqlServer struct {
	grpc.ServerStream
}

func (x *ultipaRpcsUqlServer) Send(m *UqlReply) error {
	return x.ServerStream.SendMsg(m)
}

func _UltipaRpcs_InsertNodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertNodesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaRpcsServer).InsertNodes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaRpcs/InsertNodes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaRpcsServer).InsertNodes(ctx, req.(*InsertNodesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaRpcs_InsertEdges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InsertEdgesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaRpcsServer).InsertEdges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaRpcs/InsertEdges",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaRpcsServer).InsertEdges(ctx, req.(*InsertEdgesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// UltipaRpcs_ServiceDesc is the grpc.ServiceDesc for UltipaRpcs service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var UltipaRpcs_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "ultipa.UltipaRpcs",
	HandlerType: (*UltipaRpcsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SayHello",
			Handler:    _UltipaRpcs_SayHello_Handler,
		},
		{
			MethodName: "InsertNodes",
			Handler:    _UltipaRpcs_InsertNodes_Handler,
		},
		{
			MethodName: "InsertEdges",
			Handler:    _UltipaRpcs_InsertEdges_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Uql",
			Handler:       _UltipaRpcs_Uql_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ultipa.proto",
}

// UltipaControlsClient is the client API for UltipaControls 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 UltipaControlsClient interface {
	//1.Sends a greeting
	SayHello(ctx context.Context, in *HelloUltipaRequest, opts ...grpc.CallOption) (*HelloUltipaReply, error)
	//2.用户设置(用于存储用户配置信息,用户自主控制)
	UserSetting(ctx context.Context, in *UserSettingRequest, opts ...grpc.CallOption) (*UserSettingReply, error)
	//3. 获取raft的leader
	GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderReply, error)
	//4.uql扩展，以下命令在此接口执行执行 top, kill show().* stats
	UqlEx(ctx context.Context, in *UqlRequest, opts ...grpc.CallOption) (UltipaControls_UqlExClient, error)
	//5.导出点,边数据
	Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (UltipaControls_ExportClient, error)
	//6.下载算法生成文件
	//下载算法生成文件 v2 下载文件请求改为 算法名 + 任务号
	DownloadFileV2(ctx context.Context, in *DownloadFileRequestV2, opts ...grpc.CallOption) (UltipaControls_DownloadFileV2Client, error)
	//7.算法安装
	InstallAlgo(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_InstallAlgoClient, error)
	//8.算法卸载
	UninstallAlgo(ctx context.Context, in *UninstallAlgoRequest, opts ...grpc.CallOption) (*UninstallAlgoReply, error)
	//9.remote graph loader
	Uploader(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_UploaderClient, error)
	//10.create graph by uploader
	CreateGraphByUploader(ctx context.Context, in *CreateGraphByUploaderRequest, opts ...grpc.CallOption) (*CreateGraphByUploaderReply, error)
	//11.扩展算法安装
	InstallExta(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_InstallExtaClient, error)
	//12.扩展算法卸载
	UninstallExta(ctx context.Context, in *UninstallExtaRequest, opts ...grpc.CallOption) (*UninstallExtaReply, error)
	//13.仅鉴权
	Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateReply, error)
	//14.backup data
	Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (*BackupReply, error)
}

type ultipaControlsClient struct {
	cc grpc.ClientConnInterface
}

func NewUltipaControlsClient(cc grpc.ClientConnInterface) UltipaControlsClient {
	return &ultipaControlsClient{cc}
}

func (c *ultipaControlsClient) SayHello(ctx context.Context, in *HelloUltipaRequest, opts ...grpc.CallOption) (*HelloUltipaReply, error) {
	out := new(HelloUltipaReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/SayHello", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) UserSetting(ctx context.Context, in *UserSettingRequest, opts ...grpc.CallOption) (*UserSettingReply, error) {
	out := new(UserSettingReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/UserSetting", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) GetLeader(ctx context.Context, in *GetLeaderRequest, opts ...grpc.CallOption) (*GetLeaderReply, error) {
	out := new(GetLeaderReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/GetLeader", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) UqlEx(ctx context.Context, in *UqlRequest, opts ...grpc.CallOption) (UltipaControls_UqlExClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[0], "/ultipa.UltipaControls/UqlEx", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsUqlExClient{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 UltipaControls_UqlExClient interface {
	Recv() (*UqlReply, error)
	grpc.ClientStream
}

type ultipaControlsUqlExClient struct {
	grpc.ClientStream
}

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

func (c *ultipaControlsClient) Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (UltipaControls_ExportClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[1], "/ultipa.UltipaControls/Export", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsExportClient{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 UltipaControls_ExportClient interface {
	Recv() (*ExportReply, error)
	grpc.ClientStream
}

type ultipaControlsExportClient struct {
	grpc.ClientStream
}

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

func (c *ultipaControlsClient) DownloadFileV2(ctx context.Context, in *DownloadFileRequestV2, opts ...grpc.CallOption) (UltipaControls_DownloadFileV2Client, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[2], "/ultipa.UltipaControls/DownloadFileV2", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsDownloadFileV2Client{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 UltipaControls_DownloadFileV2Client interface {
	Recv() (*DownloadFileReply, error)
	grpc.ClientStream
}

type ultipaControlsDownloadFileV2Client struct {
	grpc.ClientStream
}

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

func (c *ultipaControlsClient) InstallAlgo(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_InstallAlgoClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[3], "/ultipa.UltipaControls/InstallAlgo", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsInstallAlgoClient{stream}
	return x, nil
}

type UltipaControls_InstallAlgoClient interface {
	Send(*InstallAlgoRequest) error
	CloseAndRecv() (*InstallAlgoReply, error)
	grpc.ClientStream
}

type ultipaControlsInstallAlgoClient struct {
	grpc.ClientStream
}

func (x *ultipaControlsInstallAlgoClient) Send(m *InstallAlgoRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *ultipaControlsInstallAlgoClient) CloseAndRecv() (*InstallAlgoReply, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(InstallAlgoReply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ultipaControlsClient) UninstallAlgo(ctx context.Context, in *UninstallAlgoRequest, opts ...grpc.CallOption) (*UninstallAlgoReply, error) {
	out := new(UninstallAlgoReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/UninstallAlgo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) Uploader(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_UploaderClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[4], "/ultipa.UltipaControls/Uploader", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsUploaderClient{stream}
	return x, nil
}

type UltipaControls_UploaderClient interface {
	Send(*UploaderRequest) error
	CloseAndRecv() (*UploaderReply, error)
	grpc.ClientStream
}

type ultipaControlsUploaderClient struct {
	grpc.ClientStream
}

func (x *ultipaControlsUploaderClient) Send(m *UploaderRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *ultipaControlsUploaderClient) CloseAndRecv() (*UploaderReply, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(UploaderReply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ultipaControlsClient) CreateGraphByUploader(ctx context.Context, in *CreateGraphByUploaderRequest, opts ...grpc.CallOption) (*CreateGraphByUploaderReply, error) {
	out := new(CreateGraphByUploaderReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/CreateGraphByUploader", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) InstallExta(ctx context.Context, opts ...grpc.CallOption) (UltipaControls_InstallExtaClient, error) {
	stream, err := c.cc.NewStream(ctx, &UltipaControls_ServiceDesc.Streams[5], "/ultipa.UltipaControls/InstallExta", opts...)
	if err != nil {
		return nil, err
	}
	x := &ultipaControlsInstallExtaClient{stream}
	return x, nil
}

type UltipaControls_InstallExtaClient interface {
	Send(*InstallExtaRequest) error
	CloseAndRecv() (*InstallExtaReply, error)
	grpc.ClientStream
}

type ultipaControlsInstallExtaClient struct {
	grpc.ClientStream
}

func (x *ultipaControlsInstallExtaClient) Send(m *InstallExtaRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *ultipaControlsInstallExtaClient) CloseAndRecv() (*InstallExtaReply, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(InstallExtaReply)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *ultipaControlsClient) UninstallExta(ctx context.Context, in *UninstallExtaRequest, opts ...grpc.CallOption) (*UninstallExtaReply, error) {
	out := new(UninstallExtaReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/UninstallExta", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateReply, error) {
	out := new(AuthenticateReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/Authenticate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ultipaControlsClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (*BackupReply, error) {
	out := new(BackupReply)
	err := c.cc.Invoke(ctx, "/ultipa.UltipaControls/Backup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// UltipaControlsServer is the server API for UltipaControls service.
// All implementations must embed UnimplementedUltipaControlsServer
// for forward compatibility
type UltipaControlsServer interface {
	//1.Sends a greeting
	SayHello(context.Context, *HelloUltipaRequest) (*HelloUltipaReply, error)
	//2.用户设置(用于存储用户配置信息,用户自主控制)
	UserSetting(context.Context, *UserSettingRequest) (*UserSettingReply, error)
	//3. 获取raft的leader
	GetLeader(context.Context, *GetLeaderRequest) (*GetLeaderReply, error)
	//4.uql扩展，以下命令在此接口执行执行 top, kill show().* stats
	UqlEx(*UqlRequest, UltipaControls_UqlExServer) error
	//5.导出点,边数据
	Export(*ExportRequest, UltipaControls_ExportServer) error
	//6.下载算法生成文件
	//下载算法生成文件 v2 下载文件请求改为 算法名 + 任务号
	DownloadFileV2(*DownloadFileRequestV2, UltipaControls_DownloadFileV2Server) error
	//7.算法安装
	InstallAlgo(UltipaControls_InstallAlgoServer) error
	//8.算法卸载
	UninstallAlgo(context.Context, *UninstallAlgoRequest) (*UninstallAlgoReply, error)
	//9.remote graph loader
	Uploader(UltipaControls_UploaderServer) error
	//10.create graph by uploader
	CreateGraphByUploader(context.Context, *CreateGraphByUploaderRequest) (*CreateGraphByUploaderReply, error)
	//11.扩展算法安装
	InstallExta(UltipaControls_InstallExtaServer) error
	//12.扩展算法卸载
	UninstallExta(context.Context, *UninstallExtaRequest) (*UninstallExtaReply, error)
	//13.仅鉴权
	Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateReply, error)
	//14.backup data
	Backup(context.Context, *BackupRequest) (*BackupReply, error)
	mustEmbedUnimplementedUltipaControlsServer()
}

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

func (UnimplementedUltipaControlsServer) SayHello(context.Context, *HelloUltipaRequest) (*HelloUltipaReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}
func (UnimplementedUltipaControlsServer) UserSetting(context.Context, *UserSettingRequest) (*UserSettingReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserSetting not implemented")
}
func (UnimplementedUltipaControlsServer) GetLeader(context.Context, *GetLeaderRequest) (*GetLeaderReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLeader not implemented")
}
func (UnimplementedUltipaControlsServer) UqlEx(*UqlRequest, UltipaControls_UqlExServer) error {
	return status.Errorf(codes.Unimplemented, "method UqlEx not implemented")
}
func (UnimplementedUltipaControlsServer) Export(*ExportRequest, UltipaControls_ExportServer) error {
	return status.Errorf(codes.Unimplemented, "method Export not implemented")
}
func (UnimplementedUltipaControlsServer) DownloadFileV2(*DownloadFileRequestV2, UltipaControls_DownloadFileV2Server) error {
	return status.Errorf(codes.Unimplemented, "method DownloadFileV2 not implemented")
}
func (UnimplementedUltipaControlsServer) InstallAlgo(UltipaControls_InstallAlgoServer) error {
	return status.Errorf(codes.Unimplemented, "method InstallAlgo not implemented")
}
func (UnimplementedUltipaControlsServer) UninstallAlgo(context.Context, *UninstallAlgoRequest) (*UninstallAlgoReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UninstallAlgo not implemented")
}
func (UnimplementedUltipaControlsServer) Uploader(UltipaControls_UploaderServer) error {
	return status.Errorf(codes.Unimplemented, "method Uploader not implemented")
}
func (UnimplementedUltipaControlsServer) CreateGraphByUploader(context.Context, *CreateGraphByUploaderRequest) (*CreateGraphByUploaderReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateGraphByUploader not implemented")
}
func (UnimplementedUltipaControlsServer) InstallExta(UltipaControls_InstallExtaServer) error {
	return status.Errorf(codes.Unimplemented, "method InstallExta not implemented")
}
func (UnimplementedUltipaControlsServer) UninstallExta(context.Context, *UninstallExtaRequest) (*UninstallExtaReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UninstallExta not implemented")
}
func (UnimplementedUltipaControlsServer) Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Authenticate not implemented")
}
func (UnimplementedUltipaControlsServer) Backup(context.Context, *BackupRequest) (*BackupReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Backup not implemented")
}
func (UnimplementedUltipaControlsServer) mustEmbedUnimplementedUltipaControlsServer() {}

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

func RegisterUltipaControlsServer(s grpc.ServiceRegistrar, srv UltipaControlsServer) {
	s.RegisterService(&UltipaControls_ServiceDesc, srv)
}

func _UltipaControls_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HelloUltipaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).SayHello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/SayHello",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).SayHello(ctx, req.(*HelloUltipaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_UserSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserSettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).UserSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/UserSetting",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).UserSetting(ctx, req.(*UserSettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_GetLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLeaderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).GetLeader(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/GetLeader",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).GetLeader(ctx, req.(*GetLeaderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_UqlEx_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UqlRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UltipaControlsServer).UqlEx(m, &ultipaControlsUqlExServer{stream})
}

type UltipaControls_UqlExServer interface {
	Send(*UqlReply) error
	grpc.ServerStream
}

type ultipaControlsUqlExServer struct {
	grpc.ServerStream
}

func (x *ultipaControlsUqlExServer) Send(m *UqlReply) error {
	return x.ServerStream.SendMsg(m)
}

func _UltipaControls_Export_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ExportRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UltipaControlsServer).Export(m, &ultipaControlsExportServer{stream})
}

type UltipaControls_ExportServer interface {
	Send(*ExportReply) error
	grpc.ServerStream
}

type ultipaControlsExportServer struct {
	grpc.ServerStream
}

func (x *ultipaControlsExportServer) Send(m *ExportReply) error {
	return x.ServerStream.SendMsg(m)
}

func _UltipaControls_DownloadFileV2_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DownloadFileRequestV2)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UltipaControlsServer).DownloadFileV2(m, &ultipaControlsDownloadFileV2Server{stream})
}

type UltipaControls_DownloadFileV2Server interface {
	Send(*DownloadFileReply) error
	grpc.ServerStream
}

type ultipaControlsDownloadFileV2Server struct {
	grpc.ServerStream
}

func (x *ultipaControlsDownloadFileV2Server) Send(m *DownloadFileReply) error {
	return x.ServerStream.SendMsg(m)
}

func _UltipaControls_InstallAlgo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(UltipaControlsServer).InstallAlgo(&ultipaControlsInstallAlgoServer{stream})
}

type UltipaControls_InstallAlgoServer interface {
	SendAndClose(*InstallAlgoReply) error
	Recv() (*InstallAlgoRequest, error)
	grpc.ServerStream
}

type ultipaControlsInstallAlgoServer struct {
	grpc.ServerStream
}

func (x *ultipaControlsInstallAlgoServer) SendAndClose(m *InstallAlgoReply) error {
	return x.ServerStream.SendMsg(m)
}

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

func _UltipaControls_UninstallAlgo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UninstallAlgoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).UninstallAlgo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/UninstallAlgo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).UninstallAlgo(ctx, req.(*UninstallAlgoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_Uploader_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(UltipaControlsServer).Uploader(&ultipaControlsUploaderServer{stream})
}

type UltipaControls_UploaderServer interface {
	SendAndClose(*UploaderReply) error
	Recv() (*UploaderRequest, error)
	grpc.ServerStream
}

type ultipaControlsUploaderServer struct {
	grpc.ServerStream
}

func (x *ultipaControlsUploaderServer) SendAndClose(m *UploaderReply) error {
	return x.ServerStream.SendMsg(m)
}

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

func _UltipaControls_CreateGraphByUploader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateGraphByUploaderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).CreateGraphByUploader(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/CreateGraphByUploader",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).CreateGraphByUploader(ctx, req.(*CreateGraphByUploaderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_InstallExta_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(UltipaControlsServer).InstallExta(&ultipaControlsInstallExtaServer{stream})
}

type UltipaControls_InstallExtaServer interface {
	SendAndClose(*InstallExtaReply) error
	Recv() (*InstallExtaRequest, error)
	grpc.ServerStream
}

type ultipaControlsInstallExtaServer struct {
	grpc.ServerStream
}

func (x *ultipaControlsInstallExtaServer) SendAndClose(m *InstallExtaReply) error {
	return x.ServerStream.SendMsg(m)
}

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

func _UltipaControls_UninstallExta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UninstallExtaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).UninstallExta(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/UninstallExta",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).UninstallExta(ctx, req.(*UninstallExtaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_Authenticate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthenticateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).Authenticate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/Authenticate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).Authenticate(ctx, req.(*AuthenticateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _UltipaControls_Backup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UltipaControlsServer).Backup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ultipa.UltipaControls/Backup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UltipaControlsServer).Backup(ctx, req.(*BackupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// UltipaControls_ServiceDesc is the grpc.ServiceDesc for UltipaControls service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var UltipaControls_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "ultipa.UltipaControls",
	HandlerType: (*UltipaControlsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SayHello",
			Handler:    _UltipaControls_SayHello_Handler,
		},
		{
			MethodName: "UserSetting",
			Handler:    _UltipaControls_UserSetting_Handler,
		},
		{
			MethodName: "GetLeader",
			Handler:    _UltipaControls_GetLeader_Handler,
		},
		{
			MethodName: "UninstallAlgo",
			Handler:    _UltipaControls_UninstallAlgo_Handler,
		},
		{
			MethodName: "CreateGraphByUploader",
			Handler:    _UltipaControls_CreateGraphByUploader_Handler,
		},
		{
			MethodName: "UninstallExta",
			Handler:    _UltipaControls_UninstallExta_Handler,
		},
		{
			MethodName: "Authenticate",
			Handler:    _UltipaControls_Authenticate_Handler,
		},
		{
			MethodName: "Backup",
			Handler:    _UltipaControls_Backup_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UqlEx",
			Handler:       _UltipaControls_UqlEx_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Export",
			Handler:       _UltipaControls_Export_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DownloadFileV2",
			Handler:       _UltipaControls_DownloadFileV2_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InstallAlgo",
			Handler:       _UltipaControls_InstallAlgo_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Uploader",
			Handler:       _UltipaControls_Uploader_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "InstallExta",
			Handler:       _UltipaControls_InstallExta_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "ultipa.proto",
}
