Move codegen to build and remove macros

out/helloworld.rs

@@ -0,0 +1,128 @@
+/// The request message containing the user's name.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HelloRequest {
+    #[prost(string, tag = "1")]
+    pub name: std::string::String,
+}
+/// The response message containing the greetings
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HelloReply {
+    #[prost(string, tag = "1")]
+    pub message: std::string::String,
+}
+use tonic::_codegen::*;
+#[async_trait]
+pub trait Greeter: Send + Sync + 'static {
+    async fn say_hello(
+        &self,
+        request: tonic::Request<self::HelloRequest>,
+    ) -> Result<tonic::Response<self::HelloReply>, tonic::Status>;
+}
+#[derive(Clone)]
+pub struct GreeterServer<T: Greeter> {
+    inner: std::sync::Arc<T>,
+}
+pub struct GreeterServerSvc<T: Greeter> {
+    inner: std::sync::Arc<T>,
+}
+impl<T: Greeter> GreeterServer<T> {
+    pub fn new(inner: T) -> Self {
+        let inner = std::sync::Arc::new(inner);
+        Self { inner }
+    }
+}
+impl<T: Greeter> GreeterServerSvc<T> {
+    pub fn new(inner: std::sync::Arc<T>) -> Self {
+        Self { inner }
+    }
+}
+impl<T: Greeter, R> Service<R> for GreeterServer<T> {
+    type Response = GreeterServerSvc<T>;
+    type Error = tonic::error::Never;
+    type Future = Ready<Result<Self::Response, Self::Error>>;
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, _: R) -> Self::Future {
+        ok(GreeterServerSvc::new(self.inner.clone()))
+    }
+}
+impl<T: Greeter> Service<http::Request<tonic::_codegen::HyperBody>> for GreeterServerSvc<T> {
+    type Response = http::Response<tonic::BoxBody>;
+    type Error = tonic::error::Never;
+    type Future = BoxFuture<Self::Response, Self::Error>;
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, req: http::Request<tonic::_codegen::HyperBody>) -> Self::Future {
+        let inner = self.inner.clone();
+        match req.uri().path() {
+            "/helloworld.Greeter/SayHello" => {
+                struct SayHello<T: Greeter>(pub std::sync::Arc<T>);
+                impl<T: Greeter> tonic::server::UnaryService<self::HelloRequest> for SayHello<T> {
+                    type Response = self::HelloReply;
+                    type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                    fn call(
+                        &mut self,
+                        request: tonic::Request<self::HelloRequest>,
+                    ) -> Self::Future {
+                        let inner = self.0.clone();
+                        let fut = async move { inner.say_hello(request).await };
+                        Box::pin(fut)
+                    }
+                }
+                let inner = self.inner.clone();
+                let fut = async move {
+                    let method = SayHello(inner);
+                    let codec = tonic::codec::ProstCodec::new();
+                    let mut grpc = tonic::server::Grpc::new(codec);
+                    let res = grpc.unary(method, req).await;
+                    Ok(res)
+                };
+                Box::pin(fut)
+            }
+            _ => unimplemented!("use grpc unimplemented"),
+        }
+    }
+}
+use tonic::_codegen::*;
+pub struct GreeterClient<T> {
+    inner: tonic::client::Grpc<T>,
+}
+impl<T> GreeterClient<T>
+where
+    T: tonic::client::GrpcService<tonic::BoxBody>,
+    T::ResponseBody: tonic::body::Body + tonic::_codegen::HttpBody + Send + 'static,
+    T::Error: Into<tonic::error::Error>,
+    <T::ResponseBody as tonic::_codegen::HttpBody>::Error: Into<tonic::error::Error> + Send,
+    <T::ResponseBody as tonic::_codegen::HttpBody>::Data: Into<bytes::Bytes> + Send,
+{
+    pub fn new(inner: T) -> Self {
+        let inner = tonic::client::Grpc::new(inner);
+        Self { inner }
+    }
+    pub async fn ready(&mut self) -> Result<(), tonic::Status> {
+        self.inner.ready().await.map_err(|e| {
+            tonic::Status::new(
+                tonic::Code::Unknown,
+                format!("Service was not ready: {}", e.into()),
+            )
+        })
+    }
+    pub async fn say_hello(
+        &mut self,
+        request: tonic::Request<self::HelloRequest>,
+    ) -> Result<tonic::Response<self::HelloReply>, tonic::Status> {
+        self.ready().await?;
+        let codec = tonic::codec::ProstCodec::new();
+        let path = http::uri::PathAndQuery::from_static("/helloworld.Greeter/SayHello");
+        self.inner.unary(request, path, codec).await
+    }
+}
+impl<T: Clone> Clone for GreeterClient<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}

out/routeguide.rs

@@ -0,0 +1,303 @@
+/// Points are represented as latitude-longitude pairs in the E7 representation
+/// (degrees multiplied by 10**7 and rounded to the nearest integer).
+/// Latitudes should be in the range +/- 90 degrees and longitude should be in
+/// the range +/- 180 degrees (inclusive).
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Point {
+    #[prost(int32, tag = "1")]
+    pub latitude: i32,
+    #[prost(int32, tag = "2")]
+    pub longitude: i32,
+}
+/// A latitude-longitude rectangle, represented as two diagonally opposite
+/// points "lo" and "hi".
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Rectangle {
+    /// One corner of the rectangle.
+    #[prost(message, optional, tag = "1")]
+    pub lo: ::std::option::Option<Point>,
+    /// The other corner of the rectangle.
+    #[prost(message, optional, tag = "2")]
+    pub hi: ::std::option::Option<Point>,
+}
+/// A feature names something at a given point.
+///
+/// If a feature could not be named, the name is empty.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Feature {
+    /// The name of the feature.
+    #[prost(string, tag = "1")]
+    pub name: std::string::String,
+    /// The point where the feature is detected.
+    #[prost(message, optional, tag = "2")]
+    pub location: ::std::option::Option<Point>,
+}
+/// A RouteNote is a message sent while at a given point.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RouteNote {
+    /// The location from which the message is sent.
+    #[prost(message, optional, tag = "1")]
+    pub location: ::std::option::Option<Point>,
+    /// The message to be sent.
+    #[prost(string, tag = "2")]
+    pub message: std::string::String,
+}
+/// A RouteSummary is received in response to a RecordRoute rpc.
+///
+/// It contains the number of individual points received, the number of
+/// detected features, and the total distance covered as the cumulative sum of
+/// the distance between each point.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RouteSummary {
+    /// The number of points received.
+    #[prost(int32, tag = "1")]
+    pub point_count: i32,
+    /// The number of known features passed while traversing the route.
+    #[prost(int32, tag = "2")]
+    pub feature_count: i32,
+    /// The distance covered in metres.
+    #[prost(int32, tag = "3")]
+    pub distance: i32,
+    /// The duration of the traversal in seconds.
+    #[prost(int32, tag = "4")]
+    pub elapsed_time: i32,
+}
+use tonic::_codegen::*;
+#[async_trait]
+pub trait RouteGuide: Send + Sync + 'static {
+    async fn get_feature(
+        &self,
+        request: tonic::Request<self::Point>,
+    ) -> Result<tonic::Response<self::Feature>, tonic::Status>;
+    type ListFeaturesStream: Stream<Item = Result<self::Feature, tonic::Status>>
+        + Unpin
+        + Send
+        + 'static;
+    async fn list_features(
+        &self,
+        request: tonic::Request<self::Rectangle>,
+    ) -> Result<tonic::Response<Self::ListFeaturesStream>, tonic::Status>;
+    async fn record_route(
+        &self,
+        request: tonic::Request<tonic::Streaming<self::Point>>,
+    ) -> Result<tonic::Response<self::RouteSummary>, tonic::Status>;
+    type RouteChatStream: Stream<Item = Result<self::RouteNote, tonic::Status>>
+        + Unpin
+        + Send
+        + 'static;
+    async fn route_chat(
+        &self,
+        request: tonic::Request<tonic::Streaming<self::RouteNote>>,
+    ) -> Result<tonic::Response<Self::RouteChatStream>, tonic::Status>;
+}
+#[derive(Clone)]
+pub struct RouteGuideServer<T: RouteGuide> {
+    inner: std::sync::Arc<T>,
+}
+pub struct RouteGuideServerSvc<T: RouteGuide> {
+    inner: std::sync::Arc<T>,
+}
+impl<T: RouteGuide> RouteGuideServer<T> {
+    pub fn new(inner: T) -> Self {
+        let inner = std::sync::Arc::new(inner);
+        Self { inner }
+    }
+}
+impl<T: RouteGuide> RouteGuideServerSvc<T> {
+    pub fn new(inner: std::sync::Arc<T>) -> Self {
+        Self { inner }
+    }
+}
+impl<T: RouteGuide, R> Service<R> for RouteGuideServer<T> {
+    type Response = RouteGuideServerSvc<T>;
+    type Error = tonic::error::Never;
+    type Future = Ready<Result<Self::Response, Self::Error>>;
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, _: R) -> Self::Future {
+        ok(RouteGuideServerSvc::new(self.inner.clone()))
+    }
+}
+impl<T: RouteGuide> Service<http::Request<tonic::_codegen::HyperBody>> for RouteGuideServerSvc<T> {
+    type Response = http::Response<tonic::BoxBody>;
+    type Error = tonic::error::Never;
+    type Future = BoxFuture<Self::Response, Self::Error>;
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, req: http::Request<tonic::_codegen::HyperBody>) -> Self::Future {
+        let inner = self.inner.clone();
+        match req.uri().path() {
+            "/routeguide.RouteGuide/GetFeature" => {
+                struct GetFeature<T: RouteGuide>(pub std::sync::Arc<T>);
+                impl<T: RouteGuide> tonic::server::UnaryService<self::Point> for GetFeature<T> {
+                    type Response = self::Feature;
+                    type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                    fn call(&mut self, request: tonic::Request<self::Point>) -> Self::Future {
+                        let inner = self.0.clone();
+                        let fut = async move { inner.get_feature(request).await };
+                        Box::pin(fut)
+                    }
+                }
+                let inner = self.inner.clone();
+                let fut = async move {
+                    let method = GetFeature(inner);
+                    let codec = tonic::codec::ProstCodec::new();
+                    let mut grpc = tonic::server::Grpc::new(codec);
+                    let res = grpc.unary(method, req).await;
+                    Ok(res)
+                };
+                Box::pin(fut)
+            }
+            "/routeguide.RouteGuide/ListFeatures" => {
+                struct ListFeatures<T: RouteGuide>(pub std::sync::Arc<T>);
+                impl<T: RouteGuide> tonic::server::ServerStreamingService<self::Rectangle> for ListFeatures<T> {
+                    type Response = self::Feature;
+                    type ResponseStream = T::ListFeaturesStream;
+                    type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
+                    fn call(&mut self, request: tonic::Request<self::Rectangle>) -> Self::Future {
+                        let inner = self.0.clone();
+                        let fut = async move { inner.list_features(request).await };
+                        Box::pin(fut)
+                    }
+                }
+                let inner = self.inner.clone();
+                let fut = async move {
+                    let method = ListFeatures(inner);
+                    let codec = tonic::codec::ProstCodec::new();
+                    let mut grpc = tonic::server::Grpc::new(codec);
+                    let res = grpc.server_streaming(method, req).await;
+                    Ok(res)
+                };
+                Box::pin(fut)
+            }
+            "/routeguide.RouteGuide/RecordRoute" => {
+                struct RecordRoute<T: RouteGuide>(pub std::sync::Arc<T>);
+                impl<T: RouteGuide> tonic::server::ClientStreamingService<self::Point> for RecordRoute<T> {
+                    type Response = self::RouteSummary;
+                    type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                    fn call(
+                        &mut self,
+                        request: tonic::Request<tonic::Streaming<self::Point>>,
+                    ) -> Self::Future {
+                        let inner = self.0.clone();
+                        let fut = async move { inner.record_route(request).await };
+                        Box::pin(fut)
+                    }
+                }
+                let inner = self.inner.clone();
+                let fut = async move {
+                    let method = RecordRoute(inner);
+                    let codec = tonic::codec::ProstCodec::new();
+                    let mut grpc = tonic::server::Grpc::new(codec);
+                    let res = grpc.client_streaming(method, req).await;
+                    Ok(res)
+                };
+                Box::pin(fut)
+            }
+            "/routeguide.RouteGuide/RouteChat" => {
+                struct RouteChat<T: RouteGuide>(pub std::sync::Arc<T>);
+                impl<T: RouteGuide> tonic::server::StreamingService<self::RouteNote> for RouteChat<T> {
+                    type Response = self::RouteNote;
+                    type ResponseStream = T::RouteChatStream;
+                    type Future = BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
+                    fn call(
+                        &mut self,
+                        request: tonic::Request<tonic::Streaming<self::RouteNote>>,
+                    ) -> Self::Future {
+                        let inner = self.0.clone();
+                        let fut = async move { inner.route_chat(request).await };
+                        Box::pin(fut)
+                    }
+                }
+                let inner = self.inner.clone();
+                let fut = async move {
+                    let method = RouteChat(inner);
+                    let codec = tonic::codec::ProstCodec::new();
+                    let mut grpc = tonic::server::Grpc::new(codec);
+                    let res = grpc.streaming(method, req).await;
+                    Ok(res)
+                };
+                Box::pin(fut)
+            }
+            _ => unimplemented!("use grpc unimplemented"),
+        }
+    }
+}
+use tonic::_codegen::*;
+pub struct RouteGuideClient<T> {
+    inner: tonic::client::Grpc<T>,
+}
+impl<T> RouteGuideClient<T>
+where
+    T: tonic::client::GrpcService<tonic::BoxBody>,
+    T::ResponseBody: tonic::body::Body + tonic::_codegen::HttpBody + Send + 'static,
+    T::Error: Into<tonic::error::Error>,
+    <T::ResponseBody as tonic::_codegen::HttpBody>::Error: Into<tonic::error::Error> + Send,
+    <T::ResponseBody as tonic::_codegen::HttpBody>::Data: Into<bytes::Bytes> + Send,
+{
+    pub fn new(inner: T) -> Self {
+        let inner = tonic::client::Grpc::new(inner);
+        Self { inner }
+    }
+    pub async fn ready(&mut self) -> Result<(), tonic::Status> {
+        self.inner.ready().await.map_err(|e| {
+            tonic::Status::new(
+                tonic::Code::Unknown,
+                format!("Service was not ready: {}", e.into()),
+            )
+        })
+    }
+    pub async fn get_feature(
+        &mut self,
+        request: tonic::Request<self::Point>,
+    ) -> Result<tonic::Response<self::Feature>, tonic::Status> {
+        self.ready().await?;
+        let codec = tonic::codec::ProstCodec::new();
+        let path = http::uri::PathAndQuery::from_static("/routeguide.RouteGuide/GetFeature");
+        self.inner.unary(request, path, codec).await
+    }
+    pub async fn list_features(
+        &mut self,
+        request: tonic::Request<self::Rectangle>,
+    ) -> Result<tonic::Response<tonic::codec::Streaming<self::Feature>>, tonic::Status> {
+        self.ready().await?;
+        let codec = tonic::codec::ProstCodec::new();
+        let path = http::uri::PathAndQuery::from_static("/routeguide.RouteGuide/ListFeatures");
+        self.inner.server_streaming(request, path, codec).await
+    }
+    pub async fn record_route<S>(
+        &mut self,
+        request: tonic::Request<S>,
+    ) -> Result<tonic::Response<self::RouteSummary>, tonic::Status>
+    where
+        S: tonic::_codegen::Stream<Item = Result<self::Point, tonic::Status>> + Send + 'static,
+    {
+        self.ready().await?;
+        let codec = tonic::codec::ProstCodec::new();
+        let path = http::uri::PathAndQuery::from_static("/routeguide.RouteGuide/RecordRoute");
+        let request = request.map(|s| Box::pin(s));
+        self.inner.client_streaming(request, path, codec).await
+    }
+    pub async fn route_chat<S>(
+        &mut self,
+        request: tonic::Request<S>,
+    ) -> Result<tonic::Response<tonic::codec::Streaming<self::RouteNote>>, tonic::Status>
+    where
+        S: tonic::_codegen::Stream<Item = Result<self::RouteNote, tonic::Status>> + Send + 'static,
+    {
+        self.ready().await?;
+        let codec = tonic::codec::ProstCodec::new();
+        let path = http::uri::PathAndQuery::from_static("/routeguide.RouteGuide/RouteChat");
+        let request = request.map(|s| Box::pin(s));
+        self.inner.streaming(request, path, codec).await
+    }
+}
+impl<T: Clone> Clone for RouteGuideClient<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}