Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Templatize generic stub

Browse Source
pull/21916/head
Vijay Pai 5 years ago
parent 7aaacb4bd9
commit 0dda2e45b7
1 changed files with 34 additions and 35 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 69
      include/grpcpp/generic/generic_stub_impl.h

69
include/grpcpp/generic/generic_stub_impl.h
Unescape View File

@ -39,19 +39,21 @@ typedef ::grpc_impl::ClientAsyncResponseReader<ByteBuffer>
namespace grpc_impl {
class CompletionQueue;
/// Generic stubs provide a type-unsafe interface to call gRPC methods
/// Generic stubs provide a type-unaware interface to call gRPC methods
/// by name.
class GenericStub final {
template <class MessageType>
class TemplatedGenericStub final {
public:
explicit GenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
: channel_(channel) {}
/// Setup a call to a named method \a method using \a context, but don't
/// start it. Let it be started explicitly with StartCall and a tag.
/// The return value only indicates whether or not registration of the call
/// succeeded (i.e. the call won't proceed if the return value is nullptr).
std::unique_ptr<grpc::GenericClientAsyncReaderWriter> PrepareCall(
ClientContext* context, const grpc::string& method, CompletionQueue* cq) {
std::unique_ptr<ClientAsyncReaderWriter<MessageType, MessageType>>
PrepareCall(ClientContext* context, const grpc::string& method,
CompletionQueue* cq) {
return CallInternal(channel_.get(), context, method, cq, false, nullptr);
}
@ -59,11 +61,11 @@ class GenericStub final {
/// start it. Let it be started explicitly with StartCall.
/// The return value only indicates whether or not registration of the call
/// succeeded (i.e. the call won't proceed if the return value is nullptr).
std::unique_ptr<grpc::GenericClientAsyncResponseReader> PrepareUnaryCall(
std::unique_ptr<ClientAsyncResponseReader<MessageType>> PrepareUnaryCall(
ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer& request, CompletionQueue* cq) {
return std::unique_ptr<grpc::GenericClientAsyncResponseReader>(
internal::ClientAsyncResponseReaderFactory<grpc::ByteBuffer>::Create(
const MessageType& request, CompletionQueue* cq) {
return std::unique_ptr<ClientAsyncResponseReader<MessageType>>(
internal::ClientAsyncResponseReaderFactory<MessageType>::Create(
channel_.get(), cq,
grpc::internal::RpcMethod(method.c_str(),
grpc::internal::RpcMethod::NORMAL_RPC),
@ -76,7 +78,7 @@ class GenericStub final {
/// (i.e, initial metadata has been sent).
/// The return value only indicates whether or not registration of the call
/// succeeded (i.e. the call won't proceed if the return value is nullptr).
std::unique_ptr<grpc::GenericClientAsyncReaderWriter> Call(
std::unique_ptr<ClientAsyncReaderWriter<MessageType, MessageType>> Call(
ClientContext* context, const grpc::string& method, CompletionQueue* cq,
void* tag) {
return CallInternal(channel_.get(), context, method, cq, true, tag);
@ -86,7 +88,7 @@ class GenericStub final {
/// Setup and start a unary call to a named method \a method using
/// \a context and specifying the \a request and \a response buffers.
void UnaryCall(ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer* request, grpc::ByteBuffer* response,
const MessageType* request, MessageType* response,
std::function<void(grpc::Status)> on_completion) {
UnaryCallInternal(context, method, request, response,
std::move(on_completion));
@ -97,8 +99,7 @@ class GenericStub final {
/// Like any other reactor-based RPC, it will not be activated until
/// StartCall is invoked on its reactor.
void PrepareUnaryCall(ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer* request,
grpc::ByteBuffer* response,
const MessageType* request, MessageType* response,
ClientUnaryReactor* reactor) {
PrepareUnaryCallInternal(context, method, request, response, reactor);
}
@ -108,7 +109,7 @@ class GenericStub final {
/// until StartCall is invoked on its reactor.
void PrepareBidiStreamingCall(
ClientContext* context, const grpc::string& method,
ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>* reactor) {
ClientBidiReactor<MessageType, MessageType>* reactor) {
PrepareBidiStreamingCallInternal(context, method, reactor);
}
#endif
@ -118,12 +119,12 @@ class GenericStub final {
/// they are no longer experimental
class experimental_type {
public:
explicit experimental_type(GenericStub* stub) : stub_(stub) {}
explicit experimental_type(TemplatedGenericStub* stub) : stub_(stub) {}
/// Setup and start a unary call to a named method \a method using
/// \a context and specifying the \a request and \a response buffers.
void UnaryCall(ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer* request, grpc::ByteBuffer* response,
const MessageType* request, MessageType* response,
std::function<void(grpc::Status)> on_completion) {
stub_->UnaryCallInternal(context, method, request, response,
std::move(on_completion));
@ -134,8 +135,7 @@ class GenericStub final {
/// Like any other reactor-based RPC, it will not be activated until
/// StartCall is invoked on its reactor.
void PrepareUnaryCall(ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer* request,
grpc::ByteBuffer* response,
const MessageType* request, MessageType* response,
ClientUnaryReactor* reactor) {
stub_->PrepareUnaryCallInternal(context, method, request, response,
reactor);
@ -146,12 +146,12 @@ class GenericStub final {
/// until StartCall is invoked on its reactor.
void PrepareBidiStreamingCall(
ClientContext* context, const grpc::string& method,
ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>* reactor) {
ClientBidiReactor<MessageType, MessageType>* reactor) {
stub_->PrepareBidiStreamingCallInternal(context, method, reactor);
}
private:
GenericStub* stub_;
TemplatedGenericStub* stub_;
};
/// NOTE: The function experimental() is not stable public API. It is a view
@ -163,8 +163,7 @@ class GenericStub final {
std::shared_ptr<grpc::ChannelInterface> channel_;
void UnaryCallInternal(ClientContext* context, const grpc::string& method,
const grpc::ByteBuffer* request,
grpc::ByteBuffer* response,
const MessageType* request, MessageType* response,
std::function<void(grpc::Status)> on_completion) {
internal::CallbackUnaryCall(
channel_.get(),
@ -175,11 +174,10 @@ class GenericStub final {
void PrepareUnaryCallInternal(ClientContext* context,
const grpc::string& method,
const grpc::ByteBuffer* request,
grpc::ByteBuffer* response,
const MessageType* request,
MessageType* response,
ClientUnaryReactor* reactor) {
internal::ClientCallbackUnaryFactory::Create<grpc::ByteBuffer,
grpc::ByteBuffer>(
internal::ClientCallbackUnaryFactory::Create<MessageType, MessageType>(
channel_.get(),
grpc::internal::RpcMethod(method.c_str(),
grpc::internal::RpcMethod::NORMAL_RPC),
@ -188,21 +186,20 @@ class GenericStub final {
void PrepareBidiStreamingCallInternal(
ClientContext* context, const grpc::string& method,
ClientBidiReactor<grpc::ByteBuffer, grpc::ByteBuffer>* reactor) {
internal::ClientCallbackReaderWriterFactory<grpc::ByteBuffer,
grpc::ByteBuffer>::
ClientBidiReactor<MessageType, MessageType>* reactor) {
internal::ClientCallbackReaderWriterFactory<MessageType, MessageType>::
Create(channel_.get(),
grpc::internal::RpcMethod(
method.c_str(), grpc::internal::RpcMethod::BIDI_STREAMING),
context, reactor);
}
std::unique_ptr<grpc::GenericClientAsyncReaderWriter> CallInternal(
grpc::ChannelInterface* channel, ClientContext* context,
const grpc::string& method, CompletionQueue* cq, bool start, void* tag) {
return std::unique_ptr<grpc::GenericClientAsyncReaderWriter>(
internal::ClientAsyncReaderWriterFactory<grpc::ByteBuffer,
grpc::ByteBuffer>::
std::unique_ptr<ClientAsyncReaderWriter<MessageType, MessageType>>
CallInternal(grpc::ChannelInterface* channel, ClientContext* context,
const grpc::string& method, CompletionQueue* cq, bool start,
void* tag) {
return std::unique_ptr<ClientAsyncReaderWriter<MessageType, MessageType>>(
internal::ClientAsyncReaderWriterFactory<MessageType, MessageType>::
Create(
channel, cq,
grpc::internal::RpcMethod(
@ -211,6 +208,8 @@ class GenericStub final {
}
};
typedef TemplatedGenericStub<grpc::ByteBuffer> GenericStub;
} // namespace grpc_impl
#endif // GRPCPP_GENERIC_GENERIC_STUB_IMPL_H

Write Preview
Loading…
Cancel
Save