GRPC C++  1.39.1
generic_stub.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPCPP_GENERIC_GENERIC_STUB_H
20 #define GRPCPP_GENERIC_GENERIC_STUB_H
21 
22 #include <functional>
23 
24 #include <grpcpp/client_context.h>
26 #include <grpcpp/impl/rpc_method.h>
31 #include <grpcpp/support/status.h>
32 
33 namespace grpc {
34 
35 class CompletionQueue;
36 
37 typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
40 
44 template <class RequestType, class ResponseType>
45 class TemplatedGenericStub final {
46  public:
47  explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
48  : channel_(channel) {}
49 
54  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
55  PrepareCall(ClientContext* context, const std::string& method,
56  ::grpc::CompletionQueue* cq) {
57  return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
58  false, nullptr);
59  }
60 
65  std::unique_ptr<ClientAsyncResponseReader<ResponseType>> PrepareUnaryCall(
66  ClientContext* context, const std::string& method,
67  const RequestType& request, ::grpc::CompletionQueue* cq) {
68  return std::unique_ptr<ClientAsyncResponseReader<ResponseType>>(
69  internal::ClientAsyncResponseReaderHelper::Create<ResponseType>(
70  channel_.get(), cq,
71  grpc::internal::RpcMethod(method.c_str(),
72  /*suffix_for_stats=*/nullptr,
74  context, request));
75  }
76 
83  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>> Call(
84  ClientContext* context, const std::string& method,
85  ::grpc::CompletionQueue* cq, void* tag) {
86  return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
87  true, tag);
88  }
89 
92  void UnaryCall(ClientContext* context, const std::string& method,
93  StubOptions options, const RequestType* request,
94  ResponseType* response,
95  std::function<void(grpc::Status)> on_completion) {
96  UnaryCallInternal(context, method, options, request, response,
97  std::move(on_completion));
98  }
99 
104  void PrepareUnaryCall(ClientContext* context, const std::string& method,
105  StubOptions options, const RequestType* request,
106  ResponseType* response, ClientUnaryReactor* reactor) {
107  PrepareUnaryCallInternal(context, method, options, request, response,
108  reactor);
109  }
110 
115  ClientContext* context, const std::string& method, StubOptions options,
117  PrepareBidiStreamingCallInternal(context, method, options, reactor);
118  }
119 
120  private:
121  std::shared_ptr<grpc::ChannelInterface> channel_;
122 
123  void UnaryCallInternal(ClientContext* context, const std::string& method,
124  StubOptions options, const RequestType* request,
125  ResponseType* response,
126  std::function<void(grpc::Status)> on_completion) {
128  channel_.get(),
129  grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
131  context, request, response, std::move(on_completion));
132  }
133 
134  void PrepareUnaryCallInternal(ClientContext* context,
135  const std::string& method, StubOptions options,
136  const RequestType* request,
137  ResponseType* response,
138  ClientUnaryReactor* reactor) {
139  internal::ClientCallbackUnaryFactory::Create<RequestType, ResponseType>(
140  channel_.get(),
141  grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
143  context, request, response, reactor);
144  }
145 
146  void PrepareBidiStreamingCallInternal(
147  ClientContext* context, const std::string& method, StubOptions options,
148  ClientBidiReactor<RequestType, ResponseType>* reactor) {
150  Create(channel_.get(),
152  method.c_str(), options.suffix_for_stats(),
154  context, reactor);
155  }
156 
157  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
158  CallInternal(grpc::ChannelInterface* channel, ClientContext* context,
159  const std::string& method, StubOptions options,
160  ::grpc::CompletionQueue* cq, bool start, void* tag) {
161  return std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>(
163  Create(channel, cq,
165  method.c_str(), options.suffix_for_stats(),
167  context, start, tag));
168  }
169 };
170 
172 
173 } // namespace grpc
174 
175 #endif // GRPCPP_GENERIC_GENERIC_STUB_H
Codegen interface for grpc::Channel.
Definition: channel_interface.h:71
Async API for client-side unary RPCs, where the message response received from the server is of type ...
Definition: async_unary_call.h:220
ClientBidiReactor is the interface for a bidirectional streaming RPC.
Definition: client_callback.h:237
A ClientContext allows the person implementing a service client to:
Definition: client_context.h:193
ClientUnaryReactor is a reactor-style interface for a unary RPC.
Definition: client_callback.h:442
A thin wrapper around grpc_completion_queue (see src/core/lib/surface/completion_queue....
Definition: completion_queue.h:102
Did it work? If it didn't, why?
Definition: status.h:31
Useful interface for generated stubs.
Definition: stub_options.h:25
const char * suffix_for_stats() const
Definition: stub_options.h:34
Generic stubs provide a type-unaware interface to call gRPC methods by name.
Definition: generic_stub.h:45
std::unique_ptr< ClientAsyncResponseReader< ResponseType > > PrepareUnaryCall(ClientContext *context, const std::string &method, const RequestType &request, ::grpc::CompletionQueue *cq)
Setup a unary call to a named method method using context, and don't start it.
Definition: generic_stub.h:65
void PrepareUnaryCall(ClientContext *context, const std::string &method, StubOptions options, const RequestType *request, ResponseType *response, ClientUnaryReactor *reactor)
Setup a unary call to a named method method using context and specifying the request and response buf...
Definition: generic_stub.h:104
std::unique_ptr< ClientAsyncReaderWriter< RequestType, ResponseType > > PrepareCall(ClientContext *context, const std::string &method, ::grpc::CompletionQueue *cq)
Setup a call to a named method method using context, but don't start it.
Definition: generic_stub.h:55
std::unique_ptr< ClientAsyncReaderWriter< RequestType, ResponseType > > Call(ClientContext *context, const std::string &method, ::grpc::CompletionQueue *cq, void *tag)
DEPRECATED for multi-threaded use Begin a call to a named method method using context.
Definition: generic_stub.h:83
void PrepareBidiStreamingCall(ClientContext *context, const std::string &method, StubOptions options, ClientBidiReactor< RequestType, ResponseType > *reactor)
Setup a call to a named method method using context and tied to reactor .
Definition: generic_stub.h:114
TemplatedGenericStub(std::shared_ptr< grpc::ChannelInterface > channel)
Definition: generic_stub.h:47
void UnaryCall(ClientContext *context, const std::string &method, StubOptions options, const RequestType *request, ResponseType *response, std::function< void(grpc::Status)> on_completion)
Setup and start a unary call to a named method method using context and specifying the request and re...
Definition: generic_stub.h:92
static ClientAsyncReaderWriter< W, R > * Create(::grpc::ChannelInterface *channel, ::grpc::CompletionQueue *cq, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, bool start, void *tag)
Create a stream object.
Definition: async_stream.h:493
static void Create(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, ClientBidiReactor< Request, Response > *reactor)
Definition: client_callback.h:711
Descriptor of an RPC method.
Definition: rpc_method.h:29
@ NORMAL_RPC
Definition: rpc_method.h:32
@ BIDI_STREAMING
Definition: rpc_method.h:35
::grpc::ClientUnaryReactor ClientUnaryReactor
Definition: client_callback.h:1252
void CallbackUnaryCall(::grpc::ChannelInterface *channel, const ::grpc::internal::RpcMethod &method, ::grpc::ClientContext *context, const InputMessage *request, OutputMessage *result, std::function< void(::grpc::Status)> on_completion)
Perform a callback-based unary call.
Definition: client_callback.h:48
An Alarm posts the user-provided tag to its associated completion queue or invokes the user-provided ...
Definition: alarm.h:33
ClientAsyncResponseReader< ByteBuffer > GenericClientAsyncResponseReader
Definition: generic_stub.h:39
ClientAsyncReaderWriter< ByteBuffer, ByteBuffer > GenericClientAsyncReaderWriter
Definition: generic_stub.h:35
TemplatedGenericStub< grpc::ByteBuffer, grpc::ByteBuffer > GenericStub
Definition: generic_stub.h:171