import quincy 17.2.0

[ceph.git] / ceph / src / arrow / go / arrow / flight / Flight_grpc.pb.go

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

package flight

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.
const _ = grpc.SupportPackageIsVersion7

// FlightServiceClient is the client API for FlightService 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 FlightServiceClient interface {
        //
        // Handshake between client and server. Depending on the server, the
        // handshake may be required to determine the token that should be used for
        // future operations. Both request and response are streams to allow multiple
        // round-trips depending on auth mechanism.
        Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error)
        //
        // Get a list of available streams given a particular criteria. Most flight
        // services will expose one or more streams that are readily available for
        // retrieval. This api allows listing the streams available for
        // consumption. A user can also provide a criteria. The criteria can limit
        // the subset of streams that can be listed via this interface. Each flight
        // service allows its own definition of how to consume criteria.
        ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error)
        //
        // For a given FlightDescriptor, get information about how the flight can be
        // consumed. This is a useful interface if the consumer of the interface
        // already can identify the specific flight to consume. This interface can
        // also allow a consumer to generate a flight stream through a specified
        // descriptor. For example, a flight descriptor might be something that
        // includes a SQL statement or a Pickled Python operation that will be
        // executed. In those cases, the descriptor will not be previously available
        // within the list of available streams provided by ListFlights but will be
        // available for consumption for the duration defined by the specific flight
        // service.
        GetFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*FlightInfo, error)
        //
        // For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
        // This is used when a consumer needs the Schema of flight stream. Similar to
        // GetFlightInfo this interface may generate a new flight that was not previously
        // available in ListFlights.
        GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error)
        //
        // Retrieve a single stream associated with a particular descriptor
        // associated with the referenced ticket. A Flight can be composed of one or
        // more streams where each stream can be retrieved using a separate opaque
        // ticket that the flight service uses for managing a collection of streams.
        DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error)
        //
        // Push a stream to the flight service associated with a particular
        // flight stream. This allows a client of a flight service to upload a stream
        // of data. Depending on the particular flight service, a client consumer
        // could be allowed to upload a single stream per descriptor or an unlimited
        // number. In the latter, the service might implement a 'seal' action that
        // can be applied to a descriptor once all streams are uploaded.
        DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error)
        //
        // Open a bidirectional data channel for a given descriptor. This
        // allows clients to send and receive arbitrary Arrow data and
        // application-specific metadata in a single logical stream. In
        // contrast to DoGet/DoPut, this is more suited for clients
        // offloading computation (rather than storage) to a Flight service.
        DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error)
        //
        // Flight services can support an arbitrary number of simple actions in
        // addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
        // operations that are potentially available. DoAction allows a flight client
        // to do a specific action against a flight service. An action includes
        // opaque request and response objects that are specific to the type action
        // being undertaken.
        DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error)
        //
        // A flight service exposes all of the available action types that it has
        // along with descriptions. This allows different flight consumers to
        // understand the capabilities of the flight service.
        ListActions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (FlightService_ListActionsClient, error)
}

type flightServiceClient struct {
        cc grpc.ClientConnInterface
}

func NewFlightServiceClient(cc grpc.ClientConnInterface) FlightServiceClient {
        return &flightServiceClient{cc}
}

var flightServiceHandshakeStreamDesc = &grpc.StreamDesc{
        StreamName:    "Handshake",
        ServerStreams: true,
        ClientStreams: true,
}

func (c *flightServiceClient) Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceHandshakeStreamDesc, "/arrow.flight.protocol.FlightService/Handshake", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceHandshakeClient{stream}
        return x, nil
}

type FlightService_HandshakeClient interface {
        Send(*HandshakeRequest) error
        Recv() (*HandshakeResponse, error)
        grpc.ClientStream
}

type flightServiceHandshakeClient struct {
        grpc.ClientStream
}

func (x *flightServiceHandshakeClient) Send(m *HandshakeRequest) error {
        return x.ClientStream.SendMsg(m)
}

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

var flightServiceListFlightsStreamDesc = &grpc.StreamDesc{
        StreamName:    "ListFlights",
        ServerStreams: true,
}

func (c *flightServiceClient) ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceListFlightsStreamDesc, "/arrow.flight.protocol.FlightService/ListFlights", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceListFlightsClient{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 FlightService_ListFlightsClient interface {
        Recv() (*FlightInfo, error)
        grpc.ClientStream
}

type flightServiceListFlightsClient struct {
        grpc.ClientStream
}

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

var flightServiceGetFlightInfoStreamDesc = &grpc.StreamDesc{
        StreamName: "GetFlightInfo",
}

func (c *flightServiceClient) GetFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*FlightInfo, error) {
        out := new(FlightInfo)
        err := c.cc.Invoke(ctx, "/arrow.flight.protocol.FlightService/GetFlightInfo", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

var flightServiceGetSchemaStreamDesc = &grpc.StreamDesc{
        StreamName: "GetSchema",
}

func (c *flightServiceClient) GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error) {
        out := new(SchemaResult)
        err := c.cc.Invoke(ctx, "/arrow.flight.protocol.FlightService/GetSchema", in, out, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

var flightServiceDoGetStreamDesc = &grpc.StreamDesc{
        StreamName:    "DoGet",
        ServerStreams: true,
}

func (c *flightServiceClient) DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceDoGetStreamDesc, "/arrow.flight.protocol.FlightService/DoGet", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceDoGetClient{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 FlightService_DoGetClient interface {
        Recv() (*FlightData, error)
        grpc.ClientStream
}

type flightServiceDoGetClient struct {
        grpc.ClientStream
}

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

var flightServiceDoPutStreamDesc = &grpc.StreamDesc{
        StreamName:    "DoPut",
        ServerStreams: true,
        ClientStreams: true,
}

func (c *flightServiceClient) DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceDoPutStreamDesc, "/arrow.flight.protocol.FlightService/DoPut", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceDoPutClient{stream}
        return x, nil
}

type FlightService_DoPutClient interface {
        Send(*FlightData) error
        Recv() (*PutResult, error)
        grpc.ClientStream
}

type flightServiceDoPutClient struct {
        grpc.ClientStream
}

func (x *flightServiceDoPutClient) Send(m *FlightData) error {
        return x.ClientStream.SendMsg(m)
}

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

var flightServiceDoExchangeStreamDesc = &grpc.StreamDesc{
        StreamName:    "DoExchange",
        ServerStreams: true,
        ClientStreams: true,
}

func (c *flightServiceClient) DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceDoExchangeStreamDesc, "/arrow.flight.protocol.FlightService/DoExchange", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceDoExchangeClient{stream}
        return x, nil
}

type FlightService_DoExchangeClient interface {
        Send(*FlightData) error
        Recv() (*FlightData, error)
        grpc.ClientStream
}

type flightServiceDoExchangeClient struct {
        grpc.ClientStream
}

func (x *flightServiceDoExchangeClient) Send(m *FlightData) error {
        return x.ClientStream.SendMsg(m)
}

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

var flightServiceDoActionStreamDesc = &grpc.StreamDesc{
        StreamName:    "DoAction",
        ServerStreams: true,
}

func (c *flightServiceClient) DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceDoActionStreamDesc, "/arrow.flight.protocol.FlightService/DoAction", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceDoActionClient{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 FlightService_DoActionClient interface {
        Recv() (*Result, error)
        grpc.ClientStream
}

type flightServiceDoActionClient struct {
        grpc.ClientStream
}

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

var flightServiceListActionsStreamDesc = &grpc.StreamDesc{
        StreamName:    "ListActions",
        ServerStreams: true,
}

func (c *flightServiceClient) ListActions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (FlightService_ListActionsClient, error) {
        stream, err := c.cc.NewStream(ctx, flightServiceListActionsStreamDesc, "/arrow.flight.protocol.FlightService/ListActions", opts...)
        if err != nil {
                return nil, err
        }
        x := &flightServiceListActionsClient{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 FlightService_ListActionsClient interface {
        Recv() (*ActionType, error)
        grpc.ClientStream
}

type flightServiceListActionsClient struct {
        grpc.ClientStream
}

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

// FlightServiceService is the service API for FlightService service.
// Fields should be assigned to their respective handler implementations only before
// RegisterFlightServiceService is called.  Any unassigned fields will result in the
// handler for that method returning an Unimplemented error.
type FlightServiceService struct {
        //
        // Handshake between client and server. Depending on the server, the
        // handshake may be required to determine the token that should be used for
        // future operations. Both request and response are streams to allow multiple
        // round-trips depending on auth mechanism.
        Handshake func(FlightService_HandshakeServer) error
        //
        // Get a list of available streams given a particular criteria. Most flight
        // services will expose one or more streams that are readily available for
        // retrieval. This api allows listing the streams available for
        // consumption. A user can also provide a criteria. The criteria can limit
        // the subset of streams that can be listed via this interface. Each flight
        // service allows its own definition of how to consume criteria.
        ListFlights func(*Criteria, FlightService_ListFlightsServer) error
        //
        // For a given FlightDescriptor, get information about how the flight can be
        // consumed. This is a useful interface if the consumer of the interface
        // already can identify the specific flight to consume. This interface can
        // also allow a consumer to generate a flight stream through a specified
        // descriptor. For example, a flight descriptor might be something that
        // includes a SQL statement or a Pickled Python operation that will be
        // executed. In those cases, the descriptor will not be previously available
        // within the list of available streams provided by ListFlights but will be
        // available for consumption for the duration defined by the specific flight
        // service.
        GetFlightInfo func(context.Context, *FlightDescriptor) (*FlightInfo, error)
        //
        // For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
        // This is used when a consumer needs the Schema of flight stream. Similar to
        // GetFlightInfo this interface may generate a new flight that was not previously
        // available in ListFlights.
        GetSchema func(context.Context, *FlightDescriptor) (*SchemaResult, error)
        //
        // Retrieve a single stream associated with a particular descriptor
        // associated with the referenced ticket. A Flight can be composed of one or
        // more streams where each stream can be retrieved using a separate opaque
        // ticket that the flight service uses for managing a collection of streams.
        DoGet func(*Ticket, FlightService_DoGetServer) error
        //
        // Push a stream to the flight service associated with a particular
        // flight stream. This allows a client of a flight service to upload a stream
        // of data. Depending on the particular flight service, a client consumer
        // could be allowed to upload a single stream per descriptor or an unlimited
        // number. In the latter, the service might implement a 'seal' action that
        // can be applied to a descriptor once all streams are uploaded.
        DoPut func(FlightService_DoPutServer) error
        //
        // Open a bidirectional data channel for a given descriptor. This
        // allows clients to send and receive arbitrary Arrow data and
        // application-specific metadata in a single logical stream. In
        // contrast to DoGet/DoPut, this is more suited for clients
        // offloading computation (rather than storage) to a Flight service.
        DoExchange func(FlightService_DoExchangeServer) error
        //
        // Flight services can support an arbitrary number of simple actions in
        // addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
        // operations that are potentially available. DoAction allows a flight client
        // to do a specific action against a flight service. An action includes
        // opaque request and response objects that are specific to the type action
        // being undertaken.
        DoAction func(*Action, FlightService_DoActionServer) error
        //
        // A flight service exposes all of the available action types that it has
        // along with descriptions. This allows different flight consumers to
        // understand the capabilities of the flight service.
        ListActions func(*Empty, FlightService_ListActionsServer) error
}

func (s *FlightServiceService) handshake(_ interface{}, stream grpc.ServerStream) error {
        return s.Handshake(&flightServiceHandshakeServer{stream})
}
func (s *FlightServiceService) listFlights(_ interface{}, stream grpc.ServerStream) error {
        m := new(Criteria)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return s.ListFlights(m, &flightServiceListFlightsServer{stream})
}
func (s *FlightServiceService) getFlightInfo(_ interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(FlightDescriptor)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return s.GetFlightInfo(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     s,
                FullMethod: "/arrow.flight.protocol.FlightService/GetFlightInfo",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return s.GetFlightInfo(ctx, req.(*FlightDescriptor))
        }
        return interceptor(ctx, in, info, handler)
}
func (s *FlightServiceService) getSchema(_ interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(FlightDescriptor)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return s.GetSchema(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     s,
                FullMethod: "/arrow.flight.protocol.FlightService/GetSchema",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return s.GetSchema(ctx, req.(*FlightDescriptor))
        }
        return interceptor(ctx, in, info, handler)
}
func (s *FlightServiceService) doGet(_ interface{}, stream grpc.ServerStream) error {
        m := new(Ticket)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return s.DoGet(m, &flightServiceDoGetServer{stream})
}
func (s *FlightServiceService) doPut(_ interface{}, stream grpc.ServerStream) error {
        return s.DoPut(&flightServiceDoPutServer{stream})
}
func (s *FlightServiceService) doExchange(_ interface{}, stream grpc.ServerStream) error {
        return s.DoExchange(&flightServiceDoExchangeServer{stream})
}
func (s *FlightServiceService) doAction(_ interface{}, stream grpc.ServerStream) error {
        m := new(Action)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return s.DoAction(m, &flightServiceDoActionServer{stream})
}
func (s *FlightServiceService) listActions(_ interface{}, stream grpc.ServerStream) error {
        m := new(Empty)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return s.ListActions(m, &flightServiceListActionsServer{stream})
}

type FlightService_HandshakeServer interface {
        Send(*HandshakeResponse) error
        Recv() (*HandshakeRequest, error)
        grpc.ServerStream
}

type flightServiceHandshakeServer struct {
        grpc.ServerStream
}

func (x *flightServiceHandshakeServer) Send(m *HandshakeResponse) error {
        return x.ServerStream.SendMsg(m)
}

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

type FlightService_ListFlightsServer interface {
        Send(*FlightInfo) error
        grpc.ServerStream
}

type flightServiceListFlightsServer struct {
        grpc.ServerStream
}

func (x *flightServiceListFlightsServer) Send(m *FlightInfo) error {
        return x.ServerStream.SendMsg(m)
}

type FlightService_DoGetServer interface {
        Send(*FlightData) error
        grpc.ServerStream
}

type flightServiceDoGetServer struct {
        grpc.ServerStream
}

func (x *flightServiceDoGetServer) Send(m *FlightData) error {
        return x.ServerStream.SendMsg(m)
}

type FlightService_DoPutServer interface {
        Send(*PutResult) error
        Recv() (*FlightData, error)
        grpc.ServerStream
}

type flightServiceDoPutServer struct {
        grpc.ServerStream
}

func (x *flightServiceDoPutServer) Send(m *PutResult) error {
        return x.ServerStream.SendMsg(m)
}

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

type FlightService_DoExchangeServer interface {
        Send(*FlightData) error
        Recv() (*FlightData, error)
        grpc.ServerStream
}

type flightServiceDoExchangeServer struct {
        grpc.ServerStream
}

func (x *flightServiceDoExchangeServer) Send(m *FlightData) error {
        return x.ServerStream.SendMsg(m)
}

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

type FlightService_DoActionServer interface {
        Send(*Result) error
        grpc.ServerStream
}

type flightServiceDoActionServer struct {
        grpc.ServerStream
}

func (x *flightServiceDoActionServer) Send(m *Result) error {
        return x.ServerStream.SendMsg(m)
}

type FlightService_ListActionsServer interface {
        Send(*ActionType) error
        grpc.ServerStream
}

type flightServiceListActionsServer struct {
        grpc.ServerStream
}

func (x *flightServiceListActionsServer) Send(m *ActionType) error {
        return x.ServerStream.SendMsg(m)
}

// RegisterFlightServiceService registers a service implementation with a gRPC server.
func RegisterFlightServiceService(s grpc.ServiceRegistrar, srv *FlightServiceService) {
        srvCopy := *srv
        if srvCopy.Handshake == nil {
                srvCopy.Handshake = func(FlightService_HandshakeServer) error {
                        return status.Errorf(codes.Unimplemented, "method Handshake not implemented")
                }
        }
        if srvCopy.ListFlights == nil {
                srvCopy.ListFlights = func(*Criteria, FlightService_ListFlightsServer) error {
                        return status.Errorf(codes.Unimplemented, "method ListFlights not implemented")
                }
        }
        if srvCopy.GetFlightInfo == nil {
                srvCopy.GetFlightInfo = func(context.Context, *FlightDescriptor) (*FlightInfo, error) {
                        return nil, status.Errorf(codes.Unimplemented, "method GetFlightInfo not implemented")
                }
        }
        if srvCopy.GetSchema == nil {
                srvCopy.GetSchema = func(context.Context, *FlightDescriptor) (*SchemaResult, error) {
                        return nil, status.Errorf(codes.Unimplemented, "method GetSchema not implemented")
                }
        }
        if srvCopy.DoGet == nil {
                srvCopy.DoGet = func(*Ticket, FlightService_DoGetServer) error {
                        return status.Errorf(codes.Unimplemented, "method DoGet not implemented")
                }
        }
        if srvCopy.DoPut == nil {
                srvCopy.DoPut = func(FlightService_DoPutServer) error {
                        return status.Errorf(codes.Unimplemented, "method DoPut not implemented")
                }
        }
        if srvCopy.DoExchange == nil {
                srvCopy.DoExchange = func(FlightService_DoExchangeServer) error {
                        return status.Errorf(codes.Unimplemented, "method DoExchange not implemented")
                }
        }
        if srvCopy.DoAction == nil {
                srvCopy.DoAction = func(*Action, FlightService_DoActionServer) error {
                        return status.Errorf(codes.Unimplemented, "method DoAction not implemented")
                }
        }
        if srvCopy.ListActions == nil {
                srvCopy.ListActions = func(*Empty, FlightService_ListActionsServer) error {
                        return status.Errorf(codes.Unimplemented, "method ListActions not implemented")
                }
        }
        sd := grpc.ServiceDesc{
                ServiceName: "arrow.flight.protocol.FlightService",
                Methods: []grpc.MethodDesc{
                        {
                                MethodName: "GetFlightInfo",
                                Handler:    srvCopy.getFlightInfo,
                        },
                        {
                                MethodName: "GetSchema",
                                Handler:    srvCopy.getSchema,
                        },
                },
                Streams: []grpc.StreamDesc{
                        {
                                StreamName:    "Handshake",
                                Handler:       srvCopy.handshake,
                                ServerStreams: true,
                                ClientStreams: true,
                        },
                        {
                                StreamName:    "ListFlights",
                                Handler:       srvCopy.listFlights,
                                ServerStreams: true,
                        },
                        {
                                StreamName:    "DoGet",
                                Handler:       srvCopy.doGet,
                                ServerStreams: true,
                        },
                        {
                                StreamName:    "DoPut",
                                Handler:       srvCopy.doPut,
                                ServerStreams: true,
                                ClientStreams: true,
                        },
                        {
                                StreamName:    "DoExchange",
                                Handler:       srvCopy.doExchange,
                                ServerStreams: true,
                                ClientStreams: true,
                        },
                        {
                                StreamName:    "DoAction",
                                Handler:       srvCopy.doAction,
                                ServerStreams: true,
                        },
                        {
                                StreamName:    "ListActions",
                                Handler:       srvCopy.listActions,
                                ServerStreams: true,
                        },
                },
                Metadata: "Flight.proto",
        }

        s.RegisterService(&sd, nil)
}

// NewFlightServiceService creates a new FlightServiceService containing the
// implemented methods of the FlightService service in s.  Any unimplemented
// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
// This includes situations where the method handler is misspelled or has the wrong
// signature.  For this reason, this function should be used with great care and
// is not recommended to be used by most users.
func NewFlightServiceService(s interface{}) *FlightServiceService {
        ns := &FlightServiceService{}
        if h, ok := s.(interface {
                Handshake(FlightService_HandshakeServer) error
        }); ok {
                ns.Handshake = h.Handshake
        }
        if h, ok := s.(interface {
                ListFlights(*Criteria, FlightService_ListFlightsServer) error
        }); ok {
                ns.ListFlights = h.ListFlights
        }
        if h, ok := s.(interface {
                GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error)
        }); ok {
                ns.GetFlightInfo = h.GetFlightInfo
        }
        if h, ok := s.(interface {
                GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error)
        }); ok {
                ns.GetSchema = h.GetSchema
        }
        if h, ok := s.(interface {
                DoGet(*Ticket, FlightService_DoGetServer) error
        }); ok {
                ns.DoGet = h.DoGet
        }
        if h, ok := s.(interface {
                DoPut(FlightService_DoPutServer) error
        }); ok {
                ns.DoPut = h.DoPut
        }
        if h, ok := s.(interface {
                DoExchange(FlightService_DoExchangeServer) error
        }); ok {
                ns.DoExchange = h.DoExchange
        }
        if h, ok := s.(interface {
                DoAction(*Action, FlightService_DoActionServer) error
        }); ok {
                ns.DoAction = h.DoAction
        }
        if h, ok := s.(interface {
                ListActions(*Empty, FlightService_ListActionsServer) error
        }); ok {
                ns.ListActions = h.ListActions
        }
        return ns
}

// UnstableFlightServiceService is the service API for FlightService service.
// New methods may be added to this interface if they are added to the service
// definition, which is not a backward-compatible change.  For this reason,
// use of this type is not recommended.
type UnstableFlightServiceService interface {
        //
        // Handshake between client and server. Depending on the server, the
        // handshake may be required to determine the token that should be used for
        // future operations. Both request and response are streams to allow multiple
        // round-trips depending on auth mechanism.
        Handshake(FlightService_HandshakeServer) error
        //
        // Get a list of available streams given a particular criteria. Most flight
        // services will expose one or more streams that are readily available for
        // retrieval. This api allows listing the streams available for
        // consumption. A user can also provide a criteria. The criteria can limit
        // the subset of streams that can be listed via this interface. Each flight
        // service allows its own definition of how to consume criteria.
        ListFlights(*Criteria, FlightService_ListFlightsServer) error
        //
        // For a given FlightDescriptor, get information about how the flight can be
        // consumed. This is a useful interface if the consumer of the interface
        // already can identify the specific flight to consume. This interface can
        // also allow a consumer to generate a flight stream through a specified
        // descriptor. For example, a flight descriptor might be something that
        // includes a SQL statement or a Pickled Python operation that will be
        // executed. In those cases, the descriptor will not be previously available
        // within the list of available streams provided by ListFlights but will be
        // available for consumption for the duration defined by the specific flight
        // service.
        GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error)
        //
        // For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
        // This is used when a consumer needs the Schema of flight stream. Similar to
        // GetFlightInfo this interface may generate a new flight that was not previously
        // available in ListFlights.
        GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error)
        //
        // Retrieve a single stream associated with a particular descriptor
        // associated with the referenced ticket. A Flight can be composed of one or
        // more streams where each stream can be retrieved using a separate opaque
        // ticket that the flight service uses for managing a collection of streams.
        DoGet(*Ticket, FlightService_DoGetServer) error
        //
        // Push a stream to the flight service associated with a particular
        // flight stream. This allows a client of a flight service to upload a stream
        // of data. Depending on the particular flight service, a client consumer
        // could be allowed to upload a single stream per descriptor or an unlimited
        // number. In the latter, the service might implement a 'seal' action that
        // can be applied to a descriptor once all streams are uploaded.
        DoPut(FlightService_DoPutServer) error
        //
        // Open a bidirectional data channel for a given descriptor. This
        // allows clients to send and receive arbitrary Arrow data and
        // application-specific metadata in a single logical stream. In
        // contrast to DoGet/DoPut, this is more suited for clients
        // offloading computation (rather than storage) to a Flight service.
        DoExchange(FlightService_DoExchangeServer) error
        //
        // Flight services can support an arbitrary number of simple actions in
        // addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
        // operations that are potentially available. DoAction allows a flight client
        // to do a specific action against a flight service. An action includes
        // opaque request and response objects that are specific to the type action
        // being undertaken.
        DoAction(*Action, FlightService_DoActionServer) error
        //
        // A flight service exposes all of the available action types that it has
        // along with descriptions. This allows different flight consumers to
        // understand the capabilities of the flight service.
        ListActions(*Empty, FlightService_ListActionsServer) error
}