gopaxos_grpc.pb.go

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

package __

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

// ReplicaClient is the client API for Replica 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 ReplicaClient interface {
	Write(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Read(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Collect(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Decide(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
}

type replicaClient struct {
	cc grpc.ClientConnInterface
}

func NewReplicaClient(cc grpc.ClientConnInterface) ReplicaClient {
	return &replicaClient{cc}
}

func (c *replicaClient) Write(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.Replica/Write", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaClient) Read(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.Replica/Read", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaClient) Collect(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.Replica/Collect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaClient) Decide(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.Replica/Decide", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplicaServer is the server API for Replica service.
// All implementations must embed UnimplementedReplicaServer
// for forward compatibility
type ReplicaServer interface {
	Write(context.Context, *Message) (*Message, error)
	Read(context.Context, *Message) (*Message, error)
	Collect(context.Context, *Message) (*Message, error)
	Decide(context.Context, *Message) (*Message, error)
	mustEmbedUnimplementedReplicaServer()
}

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

func (UnimplementedReplicaServer) Write(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Write not implemented")
}
func (UnimplementedReplicaServer) Read(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func (UnimplementedReplicaServer) Collect(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Collect not implemented")
}
func (UnimplementedReplicaServer) Decide(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Decide not implemented")
}
func (UnimplementedReplicaServer) mustEmbedUnimplementedReplicaServer() {}

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

func RegisterReplicaServer(s grpc.ServiceRegistrar, srv ReplicaServer) {
	s.RegisterService(&Replica_ServiceDesc, srv)
}

func _Replica_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServer).Write(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.Replica/Write",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServer).Write(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replica_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.Replica/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServer).Read(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replica_Collect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServer).Collect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.Replica/Collect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServer).Collect(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _Replica_Decide_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServer).Decide(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.Replica/Decide",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServer).Decide(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

// Replica_ServiceDesc is the grpc.ServiceDesc for Replica service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Replica_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gopaxos.Replica",
	HandlerType: (*ReplicaServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Write",
			Handler:    _Replica_Write_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _Replica_Read_Handler,
		},
		{
			MethodName: "Collect",
			Handler:    _Replica_Collect_Handler,
		},
		{
			MethodName: "Decide",
			Handler:    _Replica_Decide_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gopaxos.proto",
}

// ReplicaLeaderClient is the client API for ReplicaLeader 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 ReplicaLeaderClient interface {
	Propose(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Collect(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Heartbeat(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
}

type replicaLeaderClient struct {
	cc grpc.ClientConnInterface
}

func NewReplicaLeaderClient(cc grpc.ClientConnInterface) ReplicaLeaderClient {
	return &replicaLeaderClient{cc}
}

func (c *replicaLeaderClient) Propose(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.ReplicaLeader/Propose", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaLeaderClient) Collect(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.ReplicaLeader/Collect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaLeaderClient) Heartbeat(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.ReplicaLeader/Heartbeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplicaLeaderServer is the server API for ReplicaLeader service.
// All implementations must embed UnimplementedReplicaLeaderServer
// for forward compatibility
type ReplicaLeaderServer interface {
	Propose(context.Context, *Message) (*Message, error)
	Collect(context.Context, *Message) (*Message, error)
	Heartbeat(context.Context, *Message) (*Message, error)
	mustEmbedUnimplementedReplicaLeaderServer()
}

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

func (UnimplementedReplicaLeaderServer) Propose(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Propose not implemented")
}
func (UnimplementedReplicaLeaderServer) Collect(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Collect not implemented")
}
func (UnimplementedReplicaLeaderServer) Heartbeat(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Heartbeat not implemented")
}
func (UnimplementedReplicaLeaderServer) mustEmbedUnimplementedReplicaLeaderServer() {}

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

func RegisterReplicaLeaderServer(s grpc.ServiceRegistrar, srv ReplicaLeaderServer) {
	s.RegisterService(&ReplicaLeader_ServiceDesc, srv)
}

func _ReplicaLeader_Propose_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaLeaderServer).Propose(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.ReplicaLeader/Propose",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaLeaderServer).Propose(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaLeader_Collect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaLeaderServer).Collect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.ReplicaLeader/Collect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaLeaderServer).Collect(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaLeader_Heartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaLeaderServer).Heartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.ReplicaLeader/Heartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaLeaderServer).Heartbeat(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

// ReplicaLeader_ServiceDesc is the grpc.ServiceDesc for ReplicaLeader service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ReplicaLeader_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gopaxos.ReplicaLeader",
	HandlerType: (*ReplicaLeaderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Propose",
			Handler:    _ReplicaLeader_Propose_Handler,
		},
		{
			MethodName: "Collect",
			Handler:    _ReplicaLeader_Collect_Handler,
		},
		{
			MethodName: "Heartbeat",
			Handler:    _ReplicaLeader_Heartbeat_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gopaxos.proto",
}

// LeaderAcceptorClient is the client API for LeaderAcceptor 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 LeaderAcceptorClient interface {
	Scouting(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
	Commanding(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error)
}

type leaderAcceptorClient struct {
	cc grpc.ClientConnInterface
}

func NewLeaderAcceptorClient(cc grpc.ClientConnInterface) LeaderAcceptorClient {
	return &leaderAcceptorClient{cc}
}

func (c *leaderAcceptorClient) Scouting(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.LeaderAcceptor/Scouting", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *leaderAcceptorClient) Commanding(ctx context.Context, in *Message, opts ...grpc.CallOption) (*Message, error) {
	out := new(Message)
	err := c.cc.Invoke(ctx, "/gopaxos.LeaderAcceptor/Commanding", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LeaderAcceptorServer is the server API for LeaderAcceptor service.
// All implementations must embed UnimplementedLeaderAcceptorServer
// for forward compatibility
type LeaderAcceptorServer interface {
	Scouting(context.Context, *Message) (*Message, error)
	Commanding(context.Context, *Message) (*Message, error)
	mustEmbedUnimplementedLeaderAcceptorServer()
}

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

func (UnimplementedLeaderAcceptorServer) Scouting(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Scouting not implemented")
}
func (UnimplementedLeaderAcceptorServer) Commanding(context.Context, *Message) (*Message, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Commanding not implemented")
}
func (UnimplementedLeaderAcceptorServer) mustEmbedUnimplementedLeaderAcceptorServer() {}

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

func RegisterLeaderAcceptorServer(s grpc.ServiceRegistrar, srv LeaderAcceptorServer) {
	s.RegisterService(&LeaderAcceptor_ServiceDesc, srv)
}

func _LeaderAcceptor_Scouting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LeaderAcceptorServer).Scouting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.LeaderAcceptor/Scouting",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LeaderAcceptorServer).Scouting(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

func _LeaderAcceptor_Commanding_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Message)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LeaderAcceptorServer).Commanding(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gopaxos.LeaderAcceptor/Commanding",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LeaderAcceptorServer).Commanding(ctx, req.(*Message))
	}
	return interceptor(ctx, in, info, handler)
}

// LeaderAcceptor_ServiceDesc is the grpc.ServiceDesc for LeaderAcceptor service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var LeaderAcceptor_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gopaxos.LeaderAcceptor",
	HandlerType: (*LeaderAcceptorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Scouting",
			Handler:    _LeaderAcceptor_Scouting_Handler,
		},
		{
			MethodName: "Commanding",
			Handler:    _LeaderAcceptor_Commanding_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gopaxos.proto",
}