generic_stub.h

Go to the documentation of this file.

/*
 *
 * 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.
 *
 */
 
#ifndef GRPCPP_GENERIC_GENERIC_STUB_H
#define GRPCPP_GENERIC_GENERIC_STUB_H
 
#include <functional>
 
#include <grpcpp/client_context.h>
#include <grpcpp/impl/rpc_method.h>
#include <grpcpp/support/async_stream_impl.h>
#include <grpcpp/support/async_unary_call_impl.h>
#include <grpcpp/support/byte_buffer.h>
#include <grpcpp/support/client_callback_impl.h>
#include <grpcpp/support/status.h>
 
namespace grpc_impl {
class CompletionQueue;
}  // namespace grpc_impl
namespace grpc {
 
typedef ::grpc_impl::ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
    GenericClientAsyncReaderWriter;
typedef ::grpc_impl::ClientAsyncResponseReader<ByteBuffer>
    GenericClientAsyncResponseReader;
 
template <class RequestType, class ResponseType>
class TemplatedGenericStub final {
 public:
  explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
      : channel_(channel) {}
 
  std::unique_ptr<
      ::grpc_impl::ClientAsyncReaderWriter<RequestType, ResponseType>>
  PrepareCall(ClientContext* context, const std::string& method,
              ::grpc_impl::CompletionQueue* cq) {
    return CallInternal(channel_.get(), context, method, cq, false, nullptr);
  }
 
  std::unique_ptr<::grpc_impl::ClientAsyncResponseReader<ResponseType>>
  PrepareUnaryCall(ClientContext* context, const std::string& method,
                   const RequestType& request,
                   ::grpc_impl::CompletionQueue* cq) {
    return std::unique_ptr<
        ::grpc_impl::ClientAsyncResponseReader<ResponseType>>(
        grpc_impl::internal::ClientAsyncResponseReaderFactory<
            ResponseType>::Create(channel_.get(), cq,
                                  grpc::internal::RpcMethod(
                                      method.c_str(),
                                      grpc::internal::RpcMethod::NORMAL_RPC),
                                  context, request, false));
  }
 
  std::unique_ptr<
      ::grpc_impl::ClientAsyncReaderWriter<RequestType, ResponseType>>
  Call(ClientContext* context, const std::string& method,
       ::grpc_impl::CompletionQueue* cq, void* tag) {
    return CallInternal(channel_.get(), context, method, cq, true, tag);
  }
 
#ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
  void UnaryCall(ClientContext* context, const std::string& method,
                 const RequestType* request, ResponseType* response,
                 std::function<void(grpc::Status)> on_completion) {
    UnaryCallInternal(context, method, request, response,
                      std::move(on_completion));
  }
 
  void PrepareUnaryCall(ClientContext* context, const std::string& method,
                        const RequestType* request, ResponseType* response,
                        ::grpc_impl::ClientUnaryReactor* reactor) {
    PrepareUnaryCallInternal(context, method, request, response, reactor);
  }
 
  void PrepareBidiStreamingCall(
      ClientContext* context, const std::string& method,
      ::grpc_impl::ClientBidiReactor<RequestType, ResponseType>* reactor) {
    PrepareBidiStreamingCallInternal(context, method, reactor);
  }
#endif
 
  class experimental_type {
   public:
    explicit experimental_type(TemplatedGenericStub* stub) : stub_(stub) {}
 
    void UnaryCall(ClientContext* context, const std::string& method,
                   const RequestType* request, ResponseType* response,
                   std::function<void(grpc::Status)> on_completion) {
      stub_->UnaryCallInternal(context, method, request, response,
                               std::move(on_completion));
    }
 
    void PrepareUnaryCall(ClientContext* context, const std::string& method,
                          const RequestType* request, ResponseType* response,
                          ::grpc_impl::ClientUnaryReactor* reactor) {
      stub_->PrepareUnaryCallInternal(context, method, request, response,
                                      reactor);
    }
 
    void PrepareBidiStreamingCall(
        ClientContext* context, const std::string& method,
        ::grpc_impl::ClientBidiReactor<RequestType, ResponseType>* reactor) {
      stub_->PrepareBidiStreamingCallInternal(context, method, reactor);
    }
 
   private:
    TemplatedGenericStub* stub_;
  };
 
  experimental_type experimental() { return experimental_type(this); }
 
 private:
  std::shared_ptr<grpc::ChannelInterface> channel_;
 
  void UnaryCallInternal(ClientContext* context, const std::string& method,
                         const RequestType* request, ResponseType* response,
                         std::function<void(grpc::Status)> on_completion) {
    ::grpc_impl::internal::CallbackUnaryCall(
        channel_.get(),
        grpc::internal::RpcMethod(method.c_str(),
                                  grpc::internal::RpcMethod::NORMAL_RPC),
        context, request, response, std::move(on_completion));
  }
 
  void PrepareUnaryCallInternal(ClientContext* context,
                                const std::string& method,
                                const RequestType* request,
                                ResponseType* response,
                                ::grpc_impl::ClientUnaryReactor* reactor) {
    ::grpc_impl::internal::ClientCallbackUnaryFactory::Create<RequestType,
                                                              ResponseType>(
        channel_.get(),
        grpc::internal::RpcMethod(method.c_str(),
                                  grpc::internal::RpcMethod::NORMAL_RPC),
        context, request, response, reactor);
  }
 
  void PrepareBidiStreamingCallInternal(
      ClientContext* context, const std::string& method,
      ::grpc_impl::ClientBidiReactor<RequestType, ResponseType>* reactor) {
    ::grpc_impl::internal::
        ClientCallbackReaderWriterFactory<RequestType, ResponseType>::Create(
            channel_.get(),
            grpc::internal::RpcMethod(
                method.c_str(), grpc::internal::RpcMethod::BIDI_STREAMING),
            context, reactor);
  }
 
  std::unique_ptr<
      ::grpc_impl::ClientAsyncReaderWriter<RequestType, ResponseType>>
  CallInternal(grpc::ChannelInterface* channel, ClientContext* context,
               const std::string& method, ::grpc_impl::CompletionQueue* cq,
               bool start, void* tag) {
    return std::unique_ptr<
        ::grpc_impl::ClientAsyncReaderWriter<RequestType, ResponseType>>(
        ::grpc_impl::internal::
            ClientAsyncReaderWriterFactory<RequestType, ResponseType>::Create(
                channel, cq,
                grpc::internal::RpcMethod(
                    method.c_str(), grpc::internal::RpcMethod::BIDI_STREAMING),
                context, start, tag));
  }
};
 
typedef TemplatedGenericStub<grpc::ByteBuffer, grpc::ByteBuffer> GenericStub;
 
}  // namespace grpc
 
#endif  // GRPCPP_GENERIC_GENERIC_STUB_H