//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             v4.24.4
// source: proto/grpcfs.proto

package pb

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.62.0 or later.
const _ = grpc.SupportPackageIsVersion8

const (
	FuseService_StatFs_FullMethodName      = "/org.apache.airavata.fuse.FuseService/StatFs"
	FuseService_FileInfo_FullMethodName    = "/org.apache.airavata.fuse.FuseService/FileInfo"
	FuseService_OpenDir_FullMethodName     = "/org.apache.airavata.fuse.FuseService/OpenDir"
	FuseService_OpenFile_FullMethodName    = "/org.apache.airavata.fuse.FuseService/OpenFile"
	FuseService_ReadDir_FullMethodName     = "/org.apache.airavata.fuse.FuseService/ReadDir"
	FuseService_ReadFile_FullMethodName    = "/org.apache.airavata.fuse.FuseService/ReadFile"
	FuseService_WriteFile_FullMethodName   = "/org.apache.airavata.fuse.FuseService/WriteFile"
	FuseService_SetInodeAtt_FullMethodName = "/org.apache.airavata.fuse.FuseService/SetInodeAtt"
)

// FuseServiceClient is the client API for FuseService 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.
//
// Service Definition
type FuseServiceClient interface {
	StatFs(ctx context.Context, in *StatFsReq, opts ...grpc.CallOption) (*StatFsRes, error)
	FileInfo(ctx context.Context, in *FileInfoReq, opts ...grpc.CallOption) (*FileInfoRes, error)
	OpenDir(ctx context.Context, in *OpenDirReq, opts ...grpc.CallOption) (*OpenDirRes, error)
	OpenFile(ctx context.Context, in *OpenFileReq, opts ...grpc.CallOption) (*OpenFileRes, error)
	ReadDir(ctx context.Context, in *ReadDirReq, opts ...grpc.CallOption) (*ReadDirRes, error)
	ReadFile(ctx context.Context, in *ReadFileReq, opts ...grpc.CallOption) (*ReadFileRes, error)
	WriteFile(ctx context.Context, in *WriteFileReq, opts ...grpc.CallOption) (*WriteFileRes, error)
	SetInodeAtt(ctx context.Context, in *SetInodeAttReq, opts ...grpc.CallOption) (*SetInodeAttRes, error)
}

type fuseServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewFuseServiceClient(cc grpc.ClientConnInterface) FuseServiceClient {
	return &fuseServiceClient{cc}
}

func (c *fuseServiceClient) StatFs(ctx context.Context, in *StatFsReq, opts ...grpc.CallOption) (*StatFsRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StatFsRes)
	err := c.cc.Invoke(ctx, FuseService_StatFs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) FileInfo(ctx context.Context, in *FileInfoReq, opts ...grpc.CallOption) (*FileInfoRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FileInfoRes)
	err := c.cc.Invoke(ctx, FuseService_FileInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) OpenDir(ctx context.Context, in *OpenDirReq, opts ...grpc.CallOption) (*OpenDirRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OpenDirRes)
	err := c.cc.Invoke(ctx, FuseService_OpenDir_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) OpenFile(ctx context.Context, in *OpenFileReq, opts ...grpc.CallOption) (*OpenFileRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OpenFileRes)
	err := c.cc.Invoke(ctx, FuseService_OpenFile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) ReadDir(ctx context.Context, in *ReadDirReq, opts ...grpc.CallOption) (*ReadDirRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReadDirRes)
	err := c.cc.Invoke(ctx, FuseService_ReadDir_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) ReadFile(ctx context.Context, in *ReadFileReq, opts ...grpc.CallOption) (*ReadFileRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReadFileRes)
	err := c.cc.Invoke(ctx, FuseService_ReadFile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) WriteFile(ctx context.Context, in *WriteFileReq, opts ...grpc.CallOption) (*WriteFileRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(WriteFileRes)
	err := c.cc.Invoke(ctx, FuseService_WriteFile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fuseServiceClient) SetInodeAtt(ctx context.Context, in *SetInodeAttReq, opts ...grpc.CallOption) (*SetInodeAttRes, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetInodeAttRes)
	err := c.cc.Invoke(ctx, FuseService_SetInodeAtt_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// FuseServiceServer is the server API for FuseService service.
// All implementations must embed UnimplementedFuseServiceServer
// for forward compatibility
//
// Service Definition
type FuseServiceServer interface {
	StatFs(context.Context, *StatFsReq) (*StatFsRes, error)
	FileInfo(context.Context, *FileInfoReq) (*FileInfoRes, error)
	OpenDir(context.Context, *OpenDirReq) (*OpenDirRes, error)
	OpenFile(context.Context, *OpenFileReq) (*OpenFileRes, error)
	ReadDir(context.Context, *ReadDirReq) (*ReadDirRes, error)
	ReadFile(context.Context, *ReadFileReq) (*ReadFileRes, error)
	WriteFile(context.Context, *WriteFileReq) (*WriteFileRes, error)
	SetInodeAtt(context.Context, *SetInodeAttReq) (*SetInodeAttRes, error)
	mustEmbedUnimplementedFuseServiceServer()
}

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

func (UnimplementedFuseServiceServer) StatFs(context.Context, *StatFsReq) (*StatFsRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StatFs not implemented")
}
func (UnimplementedFuseServiceServer) FileInfo(context.Context, *FileInfoReq) (*FileInfoRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FileInfo not implemented")
}
func (UnimplementedFuseServiceServer) OpenDir(context.Context, *OpenDirReq) (*OpenDirRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenDir not implemented")
}
func (UnimplementedFuseServiceServer) OpenFile(context.Context, *OpenFileReq) (*OpenFileRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenFile not implemented")
}
func (UnimplementedFuseServiceServer) ReadDir(context.Context, *ReadDirReq) (*ReadDirRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReadDir not implemented")
}
func (UnimplementedFuseServiceServer) ReadFile(context.Context, *ReadFileReq) (*ReadFileRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReadFile not implemented")
}
func (UnimplementedFuseServiceServer) WriteFile(context.Context, *WriteFileReq) (*WriteFileRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WriteFile not implemented")
}
func (UnimplementedFuseServiceServer) SetInodeAtt(context.Context, *SetInodeAttReq) (*SetInodeAttRes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetInodeAtt not implemented")
}
func (UnimplementedFuseServiceServer) mustEmbedUnimplementedFuseServiceServer() {}

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

func RegisterFuseServiceServer(s grpc.ServiceRegistrar, srv FuseServiceServer) {
	s.RegisterService(&FuseService_ServiceDesc, srv)
}

func _FuseService_StatFs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatFsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).StatFs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_StatFs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).StatFs(ctx, req.(*StatFsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_FileInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).FileInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_FileInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).FileInfo(ctx, req.(*FileInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_OpenDir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenDirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).OpenDir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_OpenDir_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).OpenDir(ctx, req.(*OpenDirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_OpenFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).OpenFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_OpenFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).OpenFile(ctx, req.(*OpenFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_ReadDir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadDirReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).ReadDir(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_ReadDir_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).ReadDir(ctx, req.(*ReadDirReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_ReadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).ReadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_ReadFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).ReadFile(ctx, req.(*ReadFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_WriteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WriteFileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).WriteFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_WriteFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).WriteFile(ctx, req.(*WriteFileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _FuseService_SetInodeAtt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetInodeAttReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FuseServiceServer).SetInodeAtt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FuseService_SetInodeAtt_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FuseServiceServer).SetInodeAtt(ctx, req.(*SetInodeAttReq))
	}
	return interceptor(ctx, in, info, handler)
}

// FuseService_ServiceDesc is the grpc.ServiceDesc for FuseService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var FuseService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "org.apache.airavata.fuse.FuseService",
	HandlerType: (*FuseServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StatFs",
			Handler:    _FuseService_StatFs_Handler,
		},
		{
			MethodName: "FileInfo",
			Handler:    _FuseService_FileInfo_Handler,
		},
		{
			MethodName: "OpenDir",
			Handler:    _FuseService_OpenDir_Handler,
		},
		{
			MethodName: "OpenFile",
			Handler:    _FuseService_OpenFile_Handler,
		},
		{
			MethodName: "ReadDir",
			Handler:    _FuseService_ReadDir_Handler,
		},
		{
			MethodName: "ReadFile",
			Handler:    _FuseService_ReadFile_Handler,
		},
		{
			MethodName: "WriteFile",
			Handler:    _FuseService_WriteFile_Handler,
		},
		{
			MethodName: "SetInodeAtt",
			Handler:    _FuseService_SetInodeAtt_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/grpcfs.proto",
}
