// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.25.1
// source: cache.proto

package proto

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 (
	Cache_GetContent_FullMethodName                     = "/cache.Cache/GetContent"
	Cache_HasContent_FullMethodName                     = "/cache.Cache/HasContent"
	Cache_GetContentStream_FullMethodName               = "/cache.Cache/GetContentStream"
	Cache_StoreContent_FullMethodName                   = "/cache.Cache/StoreContent"
	Cache_StoreContentFromSource_FullMethodName         = "/cache.Cache/StoreContentFromSource"
	Cache_StoreContentFromSourceWithLock_FullMethodName = "/cache.Cache/StoreContentFromSourceWithLock"
	Cache_GetState_FullMethodName                       = "/cache.Cache/GetState"
)

// CacheClient is the client API for Cache 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 CacheClient interface {
	GetContent(ctx context.Context, in *CacheGetContentRequest, opts ...grpc.CallOption) (*CacheGetContentResponse, error)
	HasContent(ctx context.Context, in *CacheHasContentRequest, opts ...grpc.CallOption) (*CacheHasContentResponse, error)
	GetContentStream(ctx context.Context, in *CacheGetContentRequest, opts ...grpc.CallOption) (Cache_GetContentStreamClient, error)
	StoreContent(ctx context.Context, opts ...grpc.CallOption) (Cache_StoreContentClient, error)
	StoreContentFromSource(ctx context.Context, in *CacheStoreContentFromSourceRequest, opts ...grpc.CallOption) (*CacheStoreContentFromSourceResponse, error)
	StoreContentFromSourceWithLock(ctx context.Context, in *CacheStoreContentFromSourceRequest, opts ...grpc.CallOption) (*CacheStoreContentFromSourceWithLockResponse, error)
	GetState(ctx context.Context, in *CacheGetStateRequest, opts ...grpc.CallOption) (*CacheGetStateResponse, error)
}

type cacheClient struct {
	cc grpc.ClientConnInterface
}

func NewCacheClient(cc grpc.ClientConnInterface) CacheClient {
	return &cacheClient{cc}
}

func (c *cacheClient) GetContent(ctx context.Context, in *CacheGetContentRequest, opts ...grpc.CallOption) (*CacheGetContentResponse, error) {
	out := new(CacheGetContentResponse)
	err := c.cc.Invoke(ctx, Cache_GetContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cacheClient) HasContent(ctx context.Context, in *CacheHasContentRequest, opts ...grpc.CallOption) (*CacheHasContentResponse, error) {
	out := new(CacheHasContentResponse)
	err := c.cc.Invoke(ctx, Cache_HasContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cacheClient) GetContentStream(ctx context.Context, in *CacheGetContentRequest, opts ...grpc.CallOption) (Cache_GetContentStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &Cache_ServiceDesc.Streams[0], Cache_GetContentStream_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &cacheGetContentStreamClient{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 Cache_GetContentStreamClient interface {
	Recv() (*CacheGetContentResponse, error)
	grpc.ClientStream
}

type cacheGetContentStreamClient struct {
	grpc.ClientStream
}

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

func (c *cacheClient) StoreContent(ctx context.Context, opts ...grpc.CallOption) (Cache_StoreContentClient, error) {
	stream, err := c.cc.NewStream(ctx, &Cache_ServiceDesc.Streams[1], Cache_StoreContent_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &cacheStoreContentClient{stream}
	return x, nil
}

type Cache_StoreContentClient interface {
	Send(*CacheStoreContentRequest) error
	CloseAndRecv() (*CacheStoreContentResponse, error)
	grpc.ClientStream
}

type cacheStoreContentClient struct {
	grpc.ClientStream
}

func (x *cacheStoreContentClient) Send(m *CacheStoreContentRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *cacheClient) StoreContentFromSource(ctx context.Context, in *CacheStoreContentFromSourceRequest, opts ...grpc.CallOption) (*CacheStoreContentFromSourceResponse, error) {
	out := new(CacheStoreContentFromSourceResponse)
	err := c.cc.Invoke(ctx, Cache_StoreContentFromSource_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cacheClient) StoreContentFromSourceWithLock(ctx context.Context, in *CacheStoreContentFromSourceRequest, opts ...grpc.CallOption) (*CacheStoreContentFromSourceWithLockResponse, error) {
	out := new(CacheStoreContentFromSourceWithLockResponse)
	err := c.cc.Invoke(ctx, Cache_StoreContentFromSourceWithLock_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cacheClient) GetState(ctx context.Context, in *CacheGetStateRequest, opts ...grpc.CallOption) (*CacheGetStateResponse, error) {
	out := new(CacheGetStateResponse)
	err := c.cc.Invoke(ctx, Cache_GetState_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CacheServer is the server API for Cache service.
// All implementations must embed UnimplementedCacheServer
// for forward compatibility
type CacheServer interface {
	GetContent(context.Context, *CacheGetContentRequest) (*CacheGetContentResponse, error)
	HasContent(context.Context, *CacheHasContentRequest) (*CacheHasContentResponse, error)
	GetContentStream(*CacheGetContentRequest, Cache_GetContentStreamServer) error
	StoreContent(Cache_StoreContentServer) error
	StoreContentFromSource(context.Context, *CacheStoreContentFromSourceRequest) (*CacheStoreContentFromSourceResponse, error)
	StoreContentFromSourceWithLock(context.Context, *CacheStoreContentFromSourceRequest) (*CacheStoreContentFromSourceWithLockResponse, error)
	GetState(context.Context, *CacheGetStateRequest) (*CacheGetStateResponse, error)
	mustEmbedUnimplementedCacheServer()
}

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

func (UnimplementedCacheServer) GetContent(context.Context, *CacheGetContentRequest) (*CacheGetContentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetContent not implemented")
}
func (UnimplementedCacheServer) HasContent(context.Context, *CacheHasContentRequest) (*CacheHasContentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HasContent not implemented")
}
func (UnimplementedCacheServer) GetContentStream(*CacheGetContentRequest, Cache_GetContentStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetContentStream not implemented")
}
func (UnimplementedCacheServer) StoreContent(Cache_StoreContentServer) error {
	return status.Errorf(codes.Unimplemented, "method StoreContent not implemented")
}
func (UnimplementedCacheServer) StoreContentFromSource(context.Context, *CacheStoreContentFromSourceRequest) (*CacheStoreContentFromSourceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreContentFromSource not implemented")
}
func (UnimplementedCacheServer) StoreContentFromSourceWithLock(context.Context, *CacheStoreContentFromSourceRequest) (*CacheStoreContentFromSourceWithLockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreContentFromSourceWithLock not implemented")
}
func (UnimplementedCacheServer) GetState(context.Context, *CacheGetStateRequest) (*CacheGetStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetState not implemented")
}
func (UnimplementedCacheServer) mustEmbedUnimplementedCacheServer() {}

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

func RegisterCacheServer(s grpc.ServiceRegistrar, srv CacheServer) {
	s.RegisterService(&Cache_ServiceDesc, srv)
}

func _Cache_GetContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CacheGetContentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CacheServer).GetContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cache_GetContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CacheServer).GetContent(ctx, req.(*CacheGetContentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cache_HasContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CacheHasContentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CacheServer).HasContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cache_HasContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CacheServer).HasContent(ctx, req.(*CacheHasContentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cache_GetContentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CacheGetContentRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CacheServer).GetContentStream(m, &cacheGetContentStreamServer{stream})
}

type Cache_GetContentStreamServer interface {
	Send(*CacheGetContentResponse) error
	grpc.ServerStream
}

type cacheGetContentStreamServer struct {
	grpc.ServerStream
}

func (x *cacheGetContentStreamServer) Send(m *CacheGetContentResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Cache_StoreContent_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(CacheServer).StoreContent(&cacheStoreContentServer{stream})
}

type Cache_StoreContentServer interface {
	SendAndClose(*CacheStoreContentResponse) error
	Recv() (*CacheStoreContentRequest, error)
	grpc.ServerStream
}

type cacheStoreContentServer struct {
	grpc.ServerStream
}

func (x *cacheStoreContentServer) SendAndClose(m *CacheStoreContentResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Cache_StoreContentFromSource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CacheStoreContentFromSourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CacheServer).StoreContentFromSource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cache_StoreContentFromSource_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CacheServer).StoreContentFromSource(ctx, req.(*CacheStoreContentFromSourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cache_StoreContentFromSourceWithLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CacheStoreContentFromSourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CacheServer).StoreContentFromSourceWithLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cache_StoreContentFromSourceWithLock_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CacheServer).StoreContentFromSourceWithLock(ctx, req.(*CacheStoreContentFromSourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Cache_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CacheGetStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CacheServer).GetState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Cache_GetState_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CacheServer).GetState(ctx, req.(*CacheGetStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Cache_ServiceDesc is the grpc.ServiceDesc for Cache service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Cache_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "cache.Cache",
	HandlerType: (*CacheServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetContent",
			Handler:    _Cache_GetContent_Handler,
		},
		{
			MethodName: "HasContent",
			Handler:    _Cache_HasContent_Handler,
		},
		{
			MethodName: "StoreContentFromSource",
			Handler:    _Cache_StoreContentFromSource_Handler,
		},
		{
			MethodName: "StoreContentFromSourceWithLock",
			Handler:    _Cache_StoreContentFromSourceWithLock_Handler,
		},
		{
			MethodName: "GetState",
			Handler:    _Cache_GetState_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetContentStream",
			Handler:       _Cache_GetContentStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StoreContent",
			Handler:       _Cache_StoreContent_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "cache.proto",
}