// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.0
// - protoc             v6.33.1
// source: redditreader.proto

package redditreader

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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	RedditReader_StreamPosts_FullMethodName     = "/redditreader.RedditReader/StreamPosts"
	RedditReader_ListPosts_FullMethodName       = "/redditreader.RedditReader/ListPosts"
	RedditReader_UpdatePost_FullMethodName      = "/redditreader.RedditReader/UpdatePost"
	RedditReader_SubmitFeedback_FullMethodName  = "/redditreader.RedditReader/SubmitFeedback"
	RedditReader_ListSubreddits_FullMethodName  = "/redditreader.RedditReader/ListSubreddits"
	RedditReader_AddSubreddit_FullMethodName    = "/redditreader.RedditReader/AddSubreddit"
	RedditReader_RemoveSubreddit_FullMethodName = "/redditreader.RedditReader/RemoveSubreddit"
	RedditReader_UpdateFilters_FullMethodName   = "/redditreader.RedditReader/UpdateFilters"
	RedditReader_Status_FullMethodName          = "/redditreader.RedditReader/Status"
)

// RedditReaderClient is the client API for RedditReader 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 RedditReaderClient interface {
	StreamPosts(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Post], error)
	ListPosts(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
	UpdatePost(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*Post, error)
	SubmitFeedback(ctx context.Context, in *FeedbackRequest, opts ...grpc.CallOption) (*FeedbackResponse, error)
	ListSubreddits(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SubredditList, error)
	AddSubreddit(ctx context.Context, in *AddSubredditRequest, opts ...grpc.CallOption) (*SubredditMsg, error)
	RemoveSubreddit(ctx context.Context, in *RemoveRequest, opts ...grpc.CallOption) (*Empty, error)
	UpdateFilters(ctx context.Context, in *FilterRequest, opts ...grpc.CallOption) (*FilterResponse, error)
	Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StatusResponse, error)
}

type redditReaderClient struct {
	cc grpc.ClientConnInterface
}

func NewRedditReaderClient(cc grpc.ClientConnInterface) RedditReaderClient {
	return &redditReaderClient{cc}
}

func (c *redditReaderClient) StreamPosts(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Post], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &RedditReader_ServiceDesc.Streams[0], RedditReader_StreamPosts_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[StreamRequest, Post]{ClientStream: 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
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RedditReader_StreamPostsClient = grpc.ServerStreamingClient[Post]

func (c *redditReaderClient) ListPosts(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListResponse)
	err := c.cc.Invoke(ctx, RedditReader_ListPosts_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) UpdatePost(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*Post, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Post)
	err := c.cc.Invoke(ctx, RedditReader_UpdatePost_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) SubmitFeedback(ctx context.Context, in *FeedbackRequest, opts ...grpc.CallOption) (*FeedbackResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FeedbackResponse)
	err := c.cc.Invoke(ctx, RedditReader_SubmitFeedback_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) ListSubreddits(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*SubredditList, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SubredditList)
	err := c.cc.Invoke(ctx, RedditReader_ListSubreddits_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) AddSubreddit(ctx context.Context, in *AddSubredditRequest, opts ...grpc.CallOption) (*SubredditMsg, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SubredditMsg)
	err := c.cc.Invoke(ctx, RedditReader_AddSubreddit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) RemoveSubreddit(ctx context.Context, in *RemoveRequest, opts ...grpc.CallOption) (*Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Empty)
	err := c.cc.Invoke(ctx, RedditReader_RemoveSubreddit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) UpdateFilters(ctx context.Context, in *FilterRequest, opts ...grpc.CallOption) (*FilterResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(FilterResponse)
	err := c.cc.Invoke(ctx, RedditReader_UpdateFilters_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *redditReaderClient) Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StatusResponse)
	err := c.cc.Invoke(ctx, RedditReader_Status_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RedditReaderServer is the server API for RedditReader service.
// All implementations must embed UnimplementedRedditReaderServer
// for forward compatibility.
type RedditReaderServer interface {
	StreamPosts(*StreamRequest, grpc.ServerStreamingServer[Post]) error
	ListPosts(context.Context, *ListRequest) (*ListResponse, error)
	UpdatePost(context.Context, *UpdateRequest) (*Post, error)
	SubmitFeedback(context.Context, *FeedbackRequest) (*FeedbackResponse, error)
	ListSubreddits(context.Context, *Empty) (*SubredditList, error)
	AddSubreddit(context.Context, *AddSubredditRequest) (*SubredditMsg, error)
	RemoveSubreddit(context.Context, *RemoveRequest) (*Empty, error)
	UpdateFilters(context.Context, *FilterRequest) (*FilterResponse, error)
	Status(context.Context, *Empty) (*StatusResponse, error)
	mustEmbedUnimplementedRedditReaderServer()
}

// UnimplementedRedditReaderServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedRedditReaderServer struct{}

func (UnimplementedRedditReaderServer) StreamPosts(*StreamRequest, grpc.ServerStreamingServer[Post]) error {
	return status.Error(codes.Unimplemented, "method StreamPosts not implemented")
}
func (UnimplementedRedditReaderServer) ListPosts(context.Context, *ListRequest) (*ListResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPosts not implemented")
}
func (UnimplementedRedditReaderServer) UpdatePost(context.Context, *UpdateRequest) (*Post, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdatePost not implemented")
}
func (UnimplementedRedditReaderServer) SubmitFeedback(context.Context, *FeedbackRequest) (*FeedbackResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SubmitFeedback not implemented")
}
func (UnimplementedRedditReaderServer) ListSubreddits(context.Context, *Empty) (*SubredditList, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSubreddits not implemented")
}
func (UnimplementedRedditReaderServer) AddSubreddit(context.Context, *AddSubredditRequest) (*SubredditMsg, error) {
	return nil, status.Error(codes.Unimplemented, "method AddSubreddit not implemented")
}
func (UnimplementedRedditReaderServer) RemoveSubreddit(context.Context, *RemoveRequest) (*Empty, error) {
	return nil, status.Error(codes.Unimplemented, "method RemoveSubreddit not implemented")
}
func (UnimplementedRedditReaderServer) UpdateFilters(context.Context, *FilterRequest) (*FilterResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateFilters not implemented")
}
func (UnimplementedRedditReaderServer) Status(context.Context, *Empty) (*StatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedRedditReaderServer) mustEmbedUnimplementedRedditReaderServer() {}
func (UnimplementedRedditReaderServer) testEmbeddedByValue()                      {}

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

func RegisterRedditReaderServer(s grpc.ServiceRegistrar, srv RedditReaderServer) {
	// If the following call panics, it indicates UnimplementedRedditReaderServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&RedditReader_ServiceDesc, srv)
}

func _RedditReader_StreamPosts_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RedditReaderServer).StreamPosts(m, &grpc.GenericServerStream[StreamRequest, Post]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type RedditReader_StreamPostsServer = grpc.ServerStreamingServer[Post]

func _RedditReader_ListPosts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).ListPosts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_ListPosts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).ListPosts(ctx, req.(*ListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_UpdatePost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).UpdatePost(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_UpdatePost_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).UpdatePost(ctx, req.(*UpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_SubmitFeedback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FeedbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).SubmitFeedback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_SubmitFeedback_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).SubmitFeedback(ctx, req.(*FeedbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_ListSubreddits_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.(RedditReaderServer).ListSubreddits(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_ListSubreddits_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).ListSubreddits(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_AddSubreddit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddSubredditRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).AddSubreddit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_AddSubreddit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).AddSubreddit(ctx, req.(*AddSubredditRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_RemoveSubreddit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).RemoveSubreddit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_RemoveSubreddit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).RemoveSubreddit(ctx, req.(*RemoveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_UpdateFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FilterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RedditReaderServer).UpdateFilters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_UpdateFilters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).UpdateFilters(ctx, req.(*FilterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RedditReader_Status_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.(RedditReaderServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RedditReader_Status_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RedditReaderServer).Status(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

// RedditReader_ServiceDesc is the grpc.ServiceDesc for RedditReader service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RedditReader_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "redditreader.RedditReader",
	HandlerType: (*RedditReaderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPosts",
			Handler:    _RedditReader_ListPosts_Handler,
		},
		{
			MethodName: "UpdatePost",
			Handler:    _RedditReader_UpdatePost_Handler,
		},
		{
			MethodName: "SubmitFeedback",
			Handler:    _RedditReader_SubmitFeedback_Handler,
		},
		{
			MethodName: "ListSubreddits",
			Handler:    _RedditReader_ListSubreddits_Handler,
		},
		{
			MethodName: "AddSubreddit",
			Handler:    _RedditReader_AddSubreddit_Handler,
		},
		{
			MethodName: "RemoveSubreddit",
			Handler:    _RedditReader_RemoveSubreddit_Handler,
		},
		{
			MethodName: "UpdateFilters",
			Handler:    _RedditReader_UpdateFilters_Handler,
		},
		{
			MethodName: "Status",
			Handler:    _RedditReader_Status_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamPosts",
			Handler:       _RedditReader_StreamPosts_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "redditreader.proto",
}