remove generated files
This commit is contained in:
Lucio Franco
@@ -1,128 +0,0 @@
|
||||
/// 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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,303 +0,0 @@
|
||||
/// 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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user