aas_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: aas/v1/aas.proto

package aasv1

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 (
	AaService_ListAas_FullMethodName  = "/aas.v1.AaService/ListAas"
	AaService_CreateAa_FullMethodName = "/aas.v1.AaService/CreateAa"
	AaService_GetAa_FullMethodName    = "/aas.v1.AaService/GetAa"
	AaService_UpdateAa_FullMethodName = "/aas.v1.AaService/UpdateAa"
	AaService_DeleteAa_FullMethodName = "/aas.v1.AaService/DeleteAa"
)

// AaServiceClient is the client API for AaService 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 AaServiceClient interface {
	ListAas(ctx context.Context, in *ListAasRequest, opts ...grpc.CallOption) (AaService_ListAasClient, error)
	CreateAa(ctx context.Context, in *CreateAaRequest, opts ...grpc.CallOption) (*CreateAaResponse, error)
	GetAa(ctx context.Context, in *GetAaRequest, opts ...grpc.CallOption) (*GetAaResponse, error)
	UpdateAa(ctx context.Context, in *UpdateAaRequest, opts ...grpc.CallOption) (*UpdateAaResponse, error)
	DeleteAa(ctx context.Context, in *DeleteAaRequest, opts ...grpc.CallOption) (*DeleteAaResponse, error)
}

type aaServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAaServiceClient(cc grpc.ClientConnInterface) AaServiceClient {
	return &aaServiceClient{cc}
}

func (c *aaServiceClient) ListAas(ctx context.Context, in *ListAasRequest, opts ...grpc.CallOption) (AaService_ListAasClient, error) {
	stream, err := c.cc.NewStream(ctx, &AaService_ServiceDesc.Streams[0], AaService_ListAas_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aaServiceListAasClient{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 AaService_ListAasClient interface {
	Recv() (*ListAasResponse, error)
	grpc.ClientStream
}

type aaServiceListAasClient struct {
	grpc.ClientStream
}

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

func (c *aaServiceClient) CreateAa(ctx context.Context, in *CreateAaRequest, opts ...grpc.CallOption) (*CreateAaResponse, error) {
	out := new(CreateAaResponse)
	err := c.cc.Invoke(ctx, AaService_CreateAa_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aaServiceClient) GetAa(ctx context.Context, in *GetAaRequest, opts ...grpc.CallOption) (*GetAaResponse, error) {
	out := new(GetAaResponse)
	err := c.cc.Invoke(ctx, AaService_GetAa_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aaServiceClient) UpdateAa(ctx context.Context, in *UpdateAaRequest, opts ...grpc.CallOption) (*UpdateAaResponse, error) {
	out := new(UpdateAaResponse)
	err := c.cc.Invoke(ctx, AaService_UpdateAa_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aaServiceClient) DeleteAa(ctx context.Context, in *DeleteAaRequest, opts ...grpc.CallOption) (*DeleteAaResponse, error) {
	out := new(DeleteAaResponse)
	err := c.cc.Invoke(ctx, AaService_DeleteAa_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AaServiceServer is the server API for AaService service.
// All implementations should embed UnimplementedAaServiceServer
// for forward compatibility
type AaServiceServer interface {
	ListAas(*ListAasRequest, AaService_ListAasServer) error
	CreateAa(context.Context, *CreateAaRequest) (*CreateAaResponse, error)
	GetAa(context.Context, *GetAaRequest) (*GetAaResponse, error)
	UpdateAa(context.Context, *UpdateAaRequest) (*UpdateAaResponse, error)
	DeleteAa(context.Context, *DeleteAaRequest) (*DeleteAaResponse, error)
}

// UnimplementedAaServiceServer should be embedded to have forward compatible implementations.
type UnimplementedAaServiceServer struct {
}

func (UnimplementedAaServiceServer) ListAas(*ListAasRequest, AaService_ListAasServer) error {
	return status.Errorf(codes.Unimplemented, "method ListAas not implemented")
}
func (UnimplementedAaServiceServer) CreateAa(context.Context, *CreateAaRequest) (*CreateAaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAa not implemented")
}
func (UnimplementedAaServiceServer) GetAa(context.Context, *GetAaRequest) (*GetAaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAa not implemented")
}
func (UnimplementedAaServiceServer) UpdateAa(context.Context, *UpdateAaRequest) (*UpdateAaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAa not implemented")
}
func (UnimplementedAaServiceServer) DeleteAa(context.Context, *DeleteAaRequest) (*DeleteAaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAa not implemented")
}

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

func RegisterAaServiceServer(s grpc.ServiceRegistrar, srv AaServiceServer) {
	s.RegisterService(&AaService_ServiceDesc, srv)
}

func _AaService_ListAas_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListAasRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AaServiceServer).ListAas(m, &aaServiceListAasServer{stream})
}

type AaService_ListAasServer interface {
	Send(*ListAasResponse) error
	grpc.ServerStream
}

type aaServiceListAasServer struct {
	grpc.ServerStream
}

func (x *aaServiceListAasServer) Send(m *ListAasResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _AaService_CreateAa_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateAaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AaServiceServer).CreateAa(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AaService_CreateAa_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AaServiceServer).CreateAa(ctx, req.(*CreateAaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AaService_GetAa_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AaServiceServer).GetAa(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AaService_GetAa_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AaServiceServer).GetAa(ctx, req.(*GetAaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AaService_UpdateAa_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AaServiceServer).UpdateAa(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AaService_UpdateAa_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AaServiceServer).UpdateAa(ctx, req.(*UpdateAaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AaService_DeleteAa_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AaServiceServer).DeleteAa(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AaService_DeleteAa_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AaServiceServer).DeleteAa(ctx, req.(*DeleteAaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AaService_ServiceDesc is the grpc.ServiceDesc for AaService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AaService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "aas.v1.AaService",
	HandlerType: (*AaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateAa",
			Handler:    _AaService_CreateAa_Handler,
		},
		{
			MethodName: "GetAa",
			Handler:    _AaService_GetAa_Handler,
		},
		{
			MethodName: "UpdateAa",
			Handler:    _AaService_UpdateAa_Handler,
		},
		{
			MethodName: "DeleteAa",
			Handler:    _AaService_DeleteAa_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListAas",
			Handler:       _AaService_ListAas_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "aas/v1/aas.proto",
}