cells-activitystream_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package activity

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

// ActivityServiceClient is the client API for ActivityService 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 ActivityServiceClient interface {
	PostActivity(ctx context.Context, opts ...grpc.CallOption) (ActivityService_PostActivityClient, error)
	StreamActivities(ctx context.Context, in *StreamActivitiesRequest, opts ...grpc.CallOption) (ActivityService_StreamActivitiesClient, error)
	UnreadActivitiesNumber(ctx context.Context, in *UnreadActivitiesRequest, opts ...grpc.CallOption) (*UnreadActivitiesResponse, error)
	PurgeActivities(ctx context.Context, in *PurgeActivitiesRequest, opts ...grpc.CallOption) (*PurgeActivitiesResponse, error)
	SetUserLastActivity(ctx context.Context, in *UserLastActivityRequest, opts ...grpc.CallOption) (*UserLastActivityResponse, error)
	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (*SubscribeResponse, error)
	SearchSubscriptions(ctx context.Context, in *SearchSubscriptionsRequest, opts ...grpc.CallOption) (ActivityService_SearchSubscriptionsClient, error)
}

type activityServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewActivityServiceClient(cc grpc.ClientConnInterface) ActivityServiceClient {
	return &activityServiceClient{cc}
}

func (c *activityServiceClient) PostActivity(ctx context.Context, opts ...grpc.CallOption) (ActivityService_PostActivityClient, error) {
	stream, err := c.cc.NewStream(ctx, &ActivityService_ServiceDesc.Streams[0], "/activity.ActivityService/PostActivity", opts...)
	if err != nil {
		return nil, err
	}
	x := &activityServicePostActivityClient{stream}
	return x, nil
}

type ActivityService_PostActivityClient interface {
	Send(*PostActivityRequest) error
	CloseAndRecv() (*PostActivityResponse, error)
	grpc.ClientStream
}

type activityServicePostActivityClient struct {
	grpc.ClientStream
}

func (x *activityServicePostActivityClient) Send(m *PostActivityRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *activityServiceClient) StreamActivities(ctx context.Context, in *StreamActivitiesRequest, opts ...grpc.CallOption) (ActivityService_StreamActivitiesClient, error) {
	stream, err := c.cc.NewStream(ctx, &ActivityService_ServiceDesc.Streams[1], "/activity.ActivityService/StreamActivities", opts...)
	if err != nil {
		return nil, err
	}
	x := &activityServiceStreamActivitiesClient{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 ActivityService_StreamActivitiesClient interface {
	Recv() (*StreamActivitiesResponse, error)
	grpc.ClientStream
}

type activityServiceStreamActivitiesClient struct {
	grpc.ClientStream
}

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

func (c *activityServiceClient) UnreadActivitiesNumber(ctx context.Context, in *UnreadActivitiesRequest, opts ...grpc.CallOption) (*UnreadActivitiesResponse, error) {
	out := new(UnreadActivitiesResponse)
	err := c.cc.Invoke(ctx, "/activity.ActivityService/UnreadActivitiesNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityServiceClient) PurgeActivities(ctx context.Context, in *PurgeActivitiesRequest, opts ...grpc.CallOption) (*PurgeActivitiesResponse, error) {
	out := new(PurgeActivitiesResponse)
	err := c.cc.Invoke(ctx, "/activity.ActivityService/PurgeActivities", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityServiceClient) SetUserLastActivity(ctx context.Context, in *UserLastActivityRequest, opts ...grpc.CallOption) (*UserLastActivityResponse, error) {
	out := new(UserLastActivityResponse)
	err := c.cc.Invoke(ctx, "/activity.ActivityService/SetUserLastActivity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityServiceClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (*SubscribeResponse, error) {
	out := new(SubscribeResponse)
	err := c.cc.Invoke(ctx, "/activity.ActivityService/Subscribe", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityServiceClient) SearchSubscriptions(ctx context.Context, in *SearchSubscriptionsRequest, opts ...grpc.CallOption) (ActivityService_SearchSubscriptionsClient, error) {
	stream, err := c.cc.NewStream(ctx, &ActivityService_ServiceDesc.Streams[2], "/activity.ActivityService/SearchSubscriptions", opts...)
	if err != nil {
		return nil, err
	}
	x := &activityServiceSearchSubscriptionsClient{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 ActivityService_SearchSubscriptionsClient interface {
	Recv() (*SearchSubscriptionsResponse, error)
	grpc.ClientStream
}

type activityServiceSearchSubscriptionsClient struct {
	grpc.ClientStream
}

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

// ActivityServiceServer is the server API for ActivityService service.
// All implementations must embed UnimplementedActivityServiceServer
// for forward compatibility
type ActivityServiceServer interface {
	PostActivity(ActivityService_PostActivityServer) error
	StreamActivities(*StreamActivitiesRequest, ActivityService_StreamActivitiesServer) error
	UnreadActivitiesNumber(context.Context, *UnreadActivitiesRequest) (*UnreadActivitiesResponse, error)
	PurgeActivities(context.Context, *PurgeActivitiesRequest) (*PurgeActivitiesResponse, error)
	SetUserLastActivity(context.Context, *UserLastActivityRequest) (*UserLastActivityResponse, error)
	Subscribe(context.Context, *SubscribeRequest) (*SubscribeResponse, error)
	SearchSubscriptions(*SearchSubscriptionsRequest, ActivityService_SearchSubscriptionsServer) error
	mustEmbedUnimplementedActivityServiceServer()
}

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

func (UnimplementedActivityServiceServer) PostActivity(ActivityService_PostActivityServer) error {
	return status.Errorf(codes.Unimplemented, "method PostActivity not implemented")
}
func (UnimplementedActivityServiceServer) StreamActivities(*StreamActivitiesRequest, ActivityService_StreamActivitiesServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamActivities not implemented")
}
func (UnimplementedActivityServiceServer) UnreadActivitiesNumber(context.Context, *UnreadActivitiesRequest) (*UnreadActivitiesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnreadActivitiesNumber not implemented")
}
func (UnimplementedActivityServiceServer) PurgeActivities(context.Context, *PurgeActivitiesRequest) (*PurgeActivitiesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PurgeActivities not implemented")
}
func (UnimplementedActivityServiceServer) SetUserLastActivity(context.Context, *UserLastActivityRequest) (*UserLastActivityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUserLastActivity not implemented")
}
func (UnimplementedActivityServiceServer) Subscribe(context.Context, *SubscribeRequest) (*SubscribeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedActivityServiceServer) SearchSubscriptions(*SearchSubscriptionsRequest, ActivityService_SearchSubscriptionsServer) error {
	return status.Errorf(codes.Unimplemented, "method SearchSubscriptions not implemented")
}
func (UnimplementedActivityServiceServer) mustEmbedUnimplementedActivityServiceServer() {}

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

func RegisterActivityServiceServer(s grpc.ServiceRegistrar, srv ActivityServiceServer) {
	s.RegisterService(&ActivityService_ServiceDesc, srv)
}

func _ActivityService_PostActivity_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ActivityServiceServer).PostActivity(&activityServicePostActivityServer{stream})
}

type ActivityService_PostActivityServer interface {
	SendAndClose(*PostActivityResponse) error
	Recv() (*PostActivityRequest, error)
	grpc.ServerStream
}

type activityServicePostActivityServer struct {
	grpc.ServerStream
}

func (x *activityServicePostActivityServer) SendAndClose(m *PostActivityResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _ActivityService_StreamActivities_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StreamActivitiesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ActivityServiceServer).StreamActivities(m, &activityServiceStreamActivitiesServer{stream})
}

type ActivityService_StreamActivitiesServer interface {
	Send(*StreamActivitiesResponse) error
	grpc.ServerStream
}

type activityServiceStreamActivitiesServer struct {
	grpc.ServerStream
}

func (x *activityServiceStreamActivitiesServer) Send(m *StreamActivitiesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ActivityService_UnreadActivitiesNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnreadActivitiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).UnreadActivitiesNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/activity.ActivityService/UnreadActivitiesNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).UnreadActivitiesNumber(ctx, req.(*UnreadActivitiesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityService_PurgeActivities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PurgeActivitiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).PurgeActivities(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/activity.ActivityService/PurgeActivities",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).PurgeActivities(ctx, req.(*PurgeActivitiesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityService_SetUserLastActivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserLastActivityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).SetUserLastActivity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/activity.ActivityService/SetUserLastActivity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).SetUserLastActivity(ctx, req.(*UserLastActivityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityService_Subscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubscribeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).Subscribe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/activity.ActivityService/Subscribe",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).Subscribe(ctx, req.(*SubscribeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityService_SearchSubscriptions_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SearchSubscriptionsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ActivityServiceServer).SearchSubscriptions(m, &activityServiceSearchSubscriptionsServer{stream})
}

type ActivityService_SearchSubscriptionsServer interface {
	Send(*SearchSubscriptionsResponse) error
	grpc.ServerStream
}

type activityServiceSearchSubscriptionsServer struct {
	grpc.ServerStream
}

func (x *activityServiceSearchSubscriptionsServer) Send(m *SearchSubscriptionsResponse) error {
	return x.ServerStream.SendMsg(m)
}

// ActivityService_ServiceDesc is the grpc.ServiceDesc for ActivityService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ActivityService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "activity.ActivityService",
	HandlerType: (*ActivityServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UnreadActivitiesNumber",
			Handler:    _ActivityService_UnreadActivitiesNumber_Handler,
		},
		{
			MethodName: "PurgeActivities",
			Handler:    _ActivityService_PurgeActivities_Handler,
		},
		{
			MethodName: "SetUserLastActivity",
			Handler:    _ActivityService_SetUserLastActivity_Handler,
		},
		{
			MethodName: "Subscribe",
			Handler:    _ActivityService_Subscribe_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "PostActivity",
			Handler:       _ActivityService_PostActivity_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "StreamActivities",
			Handler:       _ActivityService_StreamActivities_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SearchSubscriptions",
			Handler:       _ActivityService_SearchSubscriptions_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "cells-activitystream.proto",
}