grpc-swift/Examples/v2/route-guide/Generated/route_guide.grpc.swift

// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the gRPC Swift generator plugin for the protocol buffer compiler.
// Source: route_guide.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/grpc/grpc-swift

import GRPCCore
import GRPCProtobuf

internal enum Routeguide_RouteGuide {
    internal static let descriptor = GRPCCore.ServiceDescriptor.routeguide_RouteGuide
    internal enum Method {
        internal enum GetFeature {
            internal typealias Input = Routeguide_Point
            internal typealias Output = Routeguide_Feature
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Routeguide_RouteGuide.descriptor.fullyQualifiedService,
                method: "GetFeature"
            )
        }
        internal enum ListFeatures {
            internal typealias Input = Routeguide_Rectangle
            internal typealias Output = Routeguide_Feature
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Routeguide_RouteGuide.descriptor.fullyQualifiedService,
                method: "ListFeatures"
            )
        }
        internal enum RecordRoute {
            internal typealias Input = Routeguide_Point
            internal typealias Output = Routeguide_RouteSummary
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Routeguide_RouteGuide.descriptor.fullyQualifiedService,
                method: "RecordRoute"
            )
        }
        internal enum RouteChat {
            internal typealias Input = Routeguide_RouteNote
            internal typealias Output = Routeguide_RouteNote
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Routeguide_RouteGuide.descriptor.fullyQualifiedService,
                method: "RouteChat"
            )
        }
        internal static let descriptors: [GRPCCore.MethodDescriptor] = [
            GetFeature.descriptor,
            ListFeatures.descriptor,
            RecordRoute.descriptor,
            RouteChat.descriptor
        ]
    }
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias StreamingServiceProtocol = Routeguide_RouteGuideStreamingServiceProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias ServiceProtocol = Routeguide_RouteGuideServiceProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias ClientProtocol = Routeguide_RouteGuideClientProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias Client = Routeguide_RouteGuideClient
}

extension GRPCCore.ServiceDescriptor {
    internal static let routeguide_RouteGuide = Self(
        package: "routeguide",
        service: "RouteGuide"
    )
}

/// Interface exported by the server.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Routeguide_RouteGuideStreamingServiceProtocol: GRPCCore.RegistrableRPCService {
    /// A simple RPC.
    ///
    /// Obtains the feature at a given position.
    ///
    /// A feature with an empty name is returned if there's no feature at the given
    /// position.
    func getFeature(request: GRPCCore.ServerRequest.Stream<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
    
    /// A server-to-client streaming RPC.
    ///
    /// Obtains the Features available within the given Rectangle.  Results are
    /// streamed rather than returned at once (e.g. in a response message with a
    /// repeated field), as the rectangle may cover a large area and contain a
    /// huge number of features.
    func listFeatures(request: GRPCCore.ServerRequest.Stream<Routeguide_Rectangle>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
    
    /// A client-to-server streaming RPC.
    ///
    /// Accepts a stream of Points on a route being traversed, returning a
    /// RouteSummary when traversal is completed.
    func recordRoute(request: GRPCCore.ServerRequest.Stream<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteSummary>
    
    /// A Bidirectional streaming RPC.
    ///
    /// Accepts a stream of RouteNotes sent while a route is being traversed,
    /// while receiving other RouteNotes (e.g. from other users).
    func routeChat(request: GRPCCore.ServerRequest.Stream<Routeguide_RouteNote>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteNote>
}

/// Conformance to `GRPCCore.RegistrableRPCService`.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Routeguide_RouteGuide.StreamingServiceProtocol {
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal func registerMethods(with router: inout GRPCCore.RPCRouter) {
        router.registerHandler(
            forMethod: Routeguide_RouteGuide.Method.GetFeature.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_Point>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_Feature>(),
            handler: { request in
                try await self.getFeature(request: request)
            }
        )
        router.registerHandler(
            forMethod: Routeguide_RouteGuide.Method.ListFeatures.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_Rectangle>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_Feature>(),
            handler: { request in
                try await self.listFeatures(request: request)
            }
        )
        router.registerHandler(
            forMethod: Routeguide_RouteGuide.Method.RecordRoute.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_Point>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_RouteSummary>(),
            handler: { request in
                try await self.recordRoute(request: request)
            }
        )
        router.registerHandler(
            forMethod: Routeguide_RouteGuide.Method.RouteChat.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_RouteNote>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_RouteNote>(),
            handler: { request in
                try await self.routeChat(request: request)
            }
        )
    }
}

/// Interface exported by the server.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Routeguide_RouteGuideServiceProtocol: Routeguide_RouteGuide.StreamingServiceProtocol {
    /// A simple RPC.
    ///
    /// Obtains the feature at a given position.
    ///
    /// A feature with an empty name is returned if there's no feature at the given
    /// position.
    func getFeature(request: GRPCCore.ServerRequest.Single<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Single<Routeguide_Feature>
    
    /// A server-to-client streaming RPC.
    ///
    /// Obtains the Features available within the given Rectangle.  Results are
    /// streamed rather than returned at once (e.g. in a response message with a
    /// repeated field), as the rectangle may cover a large area and contain a
    /// huge number of features.
    func listFeatures(request: GRPCCore.ServerRequest.Single<Routeguide_Rectangle>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature>
    
    /// A client-to-server streaming RPC.
    ///
    /// Accepts a stream of Points on a route being traversed, returning a
    /// RouteSummary when traversal is completed.
    func recordRoute(request: GRPCCore.ServerRequest.Stream<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Single<Routeguide_RouteSummary>
    
    /// A Bidirectional streaming RPC.
    ///
    /// Accepts a stream of RouteNotes sent while a route is being traversed,
    /// while receiving other RouteNotes (e.g. from other users).
    func routeChat(request: GRPCCore.ServerRequest.Stream<Routeguide_RouteNote>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteNote>
}

/// Partial conformance to `Routeguide_RouteGuideStreamingServiceProtocol`.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Routeguide_RouteGuide.ServiceProtocol {
    internal func getFeature(request: GRPCCore.ServerRequest.Stream<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature> {
        let response = try await self.getFeature(request: GRPCCore.ServerRequest.Single(stream: request))
        return GRPCCore.ServerResponse.Stream(single: response)
    }
    
    internal func listFeatures(request: GRPCCore.ServerRequest.Stream<Routeguide_Rectangle>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_Feature> {
        let response = try await self.listFeatures(request: GRPCCore.ServerRequest.Single(stream: request))
        return response
    }
    
    internal func recordRoute(request: GRPCCore.ServerRequest.Stream<Routeguide_Point>) async throws -> GRPCCore.ServerResponse.Stream<Routeguide_RouteSummary> {
        let response = try await self.recordRoute(request: request)
        return GRPCCore.ServerResponse.Stream(single: response)
    }
}

/// Interface exported by the server.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Routeguide_RouteGuideClientProtocol: Sendable {
    /// A simple RPC.
    ///
    /// Obtains the feature at a given position.
    ///
    /// A feature with an empty name is returned if there's no feature at the given
    /// position.
    func getFeature<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// A server-to-client streaming RPC.
    ///
    /// Obtains the Features available within the given Rectangle.  Results are
    /// streamed rather than returned at once (e.g. in a response message with a
    /// repeated field), as the rectangle may cover a large area and contain a
    /// huge number of features.
    func listFeatures<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Rectangle>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// A client-to-server streaming RPC.
    ///
    /// Accepts a stream of Points on a route being traversed, returning a
    /// RouteSummary when traversal is completed.
    func recordRoute<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteSummary>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// A Bidirectional streaming RPC.
    ///
    /// Accepts a stream of RouteNotes sent while a route is being traversed,
    /// while receiving other RouteNotes (e.g. from other users).
    func routeChat<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_RouteNote>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteNote>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
    ) async throws -> R where R: Sendable
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Routeguide_RouteGuide.ClientProtocol {
    internal func getFeature<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.getFeature(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_Point>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_Feature>(),
            options: options,
            body
        )
    }
    
    internal func listFeatures<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.listFeatures(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_Rectangle>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_Feature>(),
            options: options,
            body
        )
    }
    
    internal func recordRoute<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.recordRoute(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_Point>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_RouteSummary>(),
            options: options,
            body
        )
    }
    
    internal func routeChat<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.routeChat(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Routeguide_RouteNote>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Routeguide_RouteNote>(),
            options: options,
            body
        )
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Routeguide_RouteGuide.ClientProtocol {
    /// A simple RPC.
    ///
    /// Obtains the feature at a given position.
    ///
    /// A feature with an empty name is returned if there's no feature at the given
    /// position.
    internal func getFeature<Result>(
        _ message: Routeguide_Point,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> Result = {
            try $0.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Single<Routeguide_Point>(
            message: message,
            metadata: metadata
        )
        return try await self.getFeature(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// A server-to-client streaming RPC.
    ///
    /// Obtains the Features available within the given Rectangle.  Results are
    /// streamed rather than returned at once (e.g. in a response message with a
    /// repeated field), as the rectangle may cover a large area and contain a
    /// huge number of features.
    internal func listFeatures<Result>(
        _ message: Routeguide_Rectangle,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Single<Routeguide_Rectangle>(
            message: message,
            metadata: metadata
        )
        return try await self.listFeatures(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// A client-to-server streaming RPC.
    ///
    /// Accepts a stream of Points on a route being traversed, returning a
    /// RouteSummary when traversal is completed.
    internal func recordRoute<Result>(
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Routeguide_Point>) async throws -> Void,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> Result = {
            try $0.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Stream<Routeguide_Point>(
            metadata: metadata,
            producer: requestProducer
        )
        return try await self.recordRoute(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// A Bidirectional streaming RPC.
    ///
    /// Accepts a stream of RouteNotes sent while a route is being traversed,
    /// while receiving other RouteNotes (e.g. from other users).
    internal func routeChat<Result>(
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Routeguide_RouteNote>) async throws -> Void,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>(
            metadata: metadata,
            producer: requestProducer
        )
        return try await self.routeChat(
            request: request,
            options: options,
            handleResponse
        )
    }
}

/// Interface exported by the server.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal struct Routeguide_RouteGuideClient: Routeguide_RouteGuide.ClientProtocol {
    private let client: GRPCCore.GRPCClient
    
    internal init(wrapping client: GRPCCore.GRPCClient) {
        self.client = client
    }
    
    /// A simple RPC.
    ///
    /// Obtains the feature at a given position.
    ///
    /// A feature with an empty name is returned if there's no feature at the given
    /// position.
    internal func getFeature<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Point>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_Feature>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.client.unary(
            request: request,
            descriptor: Routeguide_RouteGuide.Method.GetFeature.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// A server-to-client streaming RPC.
    ///
    /// Obtains the Features available within the given Rectangle.  Results are
    /// streamed rather than returned at once (e.g. in a response message with a
    /// repeated field), as the rectangle may cover a large area and contain a
    /// huge number of features.
    internal func listFeatures<R>(
        request: GRPCCore.ClientRequest.Single<Routeguide_Rectangle>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Rectangle>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_Feature>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_Feature>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.client.serverStreaming(
            request: request,
            descriptor: Routeguide_RouteGuide.Method.ListFeatures.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// A client-to-server streaming RPC.
    ///
    /// Accepts a stream of Points on a route being traversed, returning a
    /// RouteSummary when traversal is completed.
    internal func recordRoute<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_Point>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_Point>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteSummary>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Routeguide_RouteSummary>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.client.clientStreaming(
            request: request,
            descriptor: Routeguide_RouteGuide.Method.RecordRoute.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// A Bidirectional streaming RPC.
    ///
    /// Accepts a stream of RouteNotes sent while a route is being traversed,
    /// while receiving other RouteNotes (e.g. from other users).
    internal func routeChat<R>(
        request: GRPCCore.ClientRequest.Stream<Routeguide_RouteNote>,
        serializer: some GRPCCore.MessageSerializer<Routeguide_RouteNote>,
        deserializer: some GRPCCore.MessageDeserializer<Routeguide_RouteNote>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Routeguide_RouteNote>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.client.bidirectionalStreaming(
            request: request,
            descriptor: Routeguide_RouteGuide.Method.RouteChat.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
}