clang-format

include/grpc++/client_context.h

@@ -60,12 +60,18 @@ class ChannelInterface;
 class CompletionQueue;
 class RpcMethod;
 class Status;
-template <class R> class ClientReader;
-template <class W> class ClientWriter;
-template <class R, class W> class ClientReaderWriter;
-template <class R> class ClientAsyncReader;
-template <class W> class ClientAsyncWriter;
-template <class R, class W> class ClientAsyncReaderWriter;
+template <class R>
+class ClientReader;
+template <class W>
+class ClientWriter;
+template <class R, class W>
+class ClientReaderWriter;
+template <class R>
+class ClientAsyncReader;
+template <class W>
+class ClientAsyncWriter;
+template <class R, class W>
+class ClientAsyncReaderWriter;
 
 class ClientContext {
  public:
@@ -97,13 +103,20 @@ class ClientContext {
 
   friend class CallOpBuffer;
   friend class Channel;
-  template <class R> friend class ::grpc::ClientReader;
-  template <class W> friend class ::grpc::ClientWriter;
-  template <class R, class W> friend class ::grpc::ClientReaderWriter;
-  template <class R> friend class ::grpc::ClientAsyncReader;
-  template <class W> friend class ::grpc::ClientAsyncWriter;
-  template <class R, class W> friend class ::grpc::ClientAsyncReaderWriter;
-  friend Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
+  template <class R>
+  friend class ::grpc::ClientReader;
+  template <class W>
+  friend class ::grpc::ClientWriter;
+  template <class R, class W>
+  friend class ::grpc::ClientReaderWriter;
+  template <class R>
+  friend class ::grpc::ClientAsyncReader;
+  template <class W>
+  friend class ::grpc::ClientAsyncWriter;
+  template <class R, class W>
+  friend class ::grpc::ClientAsyncReaderWriter;
+  friend Status BlockingUnaryCall(ChannelInterface *channel,
+                                  const RpcMethod &method,
                                   ClientContext *context,
                                   const google::protobuf::Message &request,
                                   google::protobuf::Message *result);

include/grpc++/completion_queue.h

@@ -84,14 +84,21 @@ class CompletionQueue {
   grpc_completion_queue *cq() { return cq_; }
 
  private:
-  template <class R> friend class ::grpc::ClientReader;
-  template <class W> friend class ::grpc::ClientWriter;
-  template <class R, class W> friend class ::grpc::ClientReaderWriter;
-  template <class R> friend class ::grpc::ServerReader;
-  template <class W> friend class ::grpc::ServerWriter;
-  template <class R, class W> friend class ::grpc::ServerReaderWriter;
+  template <class R>
+  friend class ::grpc::ClientReader;
+  template <class W>
+  friend class ::grpc::ClientWriter;
+  template <class R, class W>
+  friend class ::grpc::ClientReaderWriter;
+  template <class R>
+  friend class ::grpc::ServerReader;
+  template <class W>
+  friend class ::grpc::ServerWriter;
+  template <class R, class W>
+  friend class ::grpc::ServerReaderWriter;
   friend class ::grpc::Server;
-  friend Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
+  friend Status BlockingUnaryCall(ChannelInterface *channel,
+                                  const RpcMethod &method,
                                   ClientContext *context,
                                   const google::protobuf::Message &request,
                                   google::protobuf::Message *result);

include/grpc++/impl/call.h

@@ -85,6 +85,7 @@ class CallOpBuffer : public CompletionQueueTag {
   void FinalizeResult(void **tag, bool *status) override;
 
   bool got_message = false;
+
  private:
   void *return_tag_ = nullptr;
   // Send initial metadata

include/grpc++/impl/client_unary_call.h

@@ -64,4 +64,3 @@ Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
 }  // namespace grpc
 
 #endif
-

include/grpc++/impl/rpc_service_method.h

@@ -55,14 +55,10 @@ class MethodHandler {
  public:
   virtual ~MethodHandler() {}
   struct HandlerParameter {
-    HandlerParameter(Call *c,
-                     ServerContext* context,
+    HandlerParameter(Call* c, ServerContext* context,
                      const google::protobuf::Message* req,
                      google::protobuf::Message* resp)
-        : call(c),
-          server_context(context),
-          request(req),
-          response(resp) {}
+        : call(c), server_context(context), request(req), response(resp) {}
     Call* call;
     ServerContext* server_context;
     const google::protobuf::Message* request;
@@ -152,7 +148,8 @@ class BidiStreamingHandler : public MethodHandler {
       : func_(func), service_(service) {}
 
   Status RunHandler(const HandlerParameter& param) final {
-    ServerReaderWriter<ResponseType, RequestType> stream(param.call, param.server_context);
+    ServerReaderWriter<ResponseType, RequestType> stream(param.call,
+                                                         param.server_context);
     return func_(service_, param.server_context, &stream);
   }
 
@@ -195,9 +192,7 @@ class RpcServiceMethod : public RpcMethod {
 class RpcService {
  public:
   // Takes ownership.
-  void AddMethod(RpcServiceMethod* method) {
-    methods_.emplace_back(method);
-  }
+  void AddMethod(RpcServiceMethod* method) { methods_.emplace_back(method); }
 
   RpcServiceMethod* GetMethod(int i) { return methods_[i].get(); }
   int GetMethodCount() const { return methods_.size(); }

include/grpc++/stream.h

@@ -88,8 +88,7 @@ class ClientReader final : public ClientStreamingInterface,
  public:
   // Blocking create a stream and write the first request out.
   ClientReader(ChannelInterface* channel, const RpcMethod& method,
-               ClientContext *context,
-               const google::protobuf::Message &request)
+               ClientContext* context, const google::protobuf::Message& request)
       : context_(context), call_(channel->CreateCall(method, context, &cq_)) {
     CallOpBuffer buf;
     buf.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -145,9 +144,9 @@ class ClientWriter final : public ClientStreamingInterface,
  public:
   // Blocking create a stream.
   ClientWriter(ChannelInterface* channel, const RpcMethod& method,
-               ClientContext *context,
-               google::protobuf::Message *response)
-      : context_(context), response_(response),
+               ClientContext* context, google::protobuf::Message* response)
+      : context_(context),
+        response_(response),
         call_(channel->CreateCall(method, context, &cq_)) {
     CallOpBuffer buf;
     buf.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -194,8 +193,8 @@ class ClientReaderWriter final : public ClientStreamingInterface,
                                  public ReaderInterface<R> {
  public:
   // Blocking create a stream.
-  ClientReaderWriter(ChannelInterface *channel,
-                     const RpcMethod &method, ClientContext *context)
+  ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method,
+                     ClientContext* context)
       : context_(context), call_(channel->CreateCall(method, context, &cq_)) {
     CallOpBuffer buf;
     buf.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -445,7 +444,8 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
   ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
                     google::protobuf::Message* response, void* tag)
-      : context_(context), response_(response),
+      : context_(context),
+        response_(response),
         call_(channel->CreateCall(method, context, cq)) {
     init_buf_.Reset(tag);
     init_buf_.AddSendInitialMetadata(&context->send_initial_metadata_);
@@ -502,7 +502,8 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
                                       public AsyncReaderInterface<R> {
  public:
   ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq,
-                     const RpcMethod &method, ClientContext *context, void* tag)
+                          const RpcMethod& method, ClientContext* context,
+                          void* tag)
       : context_(context), call_(channel->CreateCall(method, context, cq)) {
     init_buf_.Reset(tag);
     init_buf_.AddSendInitialMetadata(&context->send_initial_metadata_);

src/cpp/client/channel.cc

@@ -93,8 +93,7 @@ void Channel::PerformOpsOnCall(CallOpBuffer *buf, Call *call) {
   grpc_op ops[MAX_OPS];
   buf->FillOps(ops, &nops);
   GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call->call(), ops, nops,
-                                   buf));
+             grpc_call_start_batch(call->call(), ops, nops, buf));
 }
 
 }  // namespace grpc

src/cpp/client/channel.h

@@ -59,8 +59,7 @@ class Channel final : public ChannelInterface {
 
   virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
                           CompletionQueue *cq) override;
-  virtual void PerformOpsOnCall(CallOpBuffer *ops,
-                                Call *call) override;
+  virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) override;
 
  private:
   const grpc::string target_;

src/cpp/common/call.cc

@@ -95,13 +95,13 @@ namespace {
 // mess. Make sure it does not happen.
 grpc_metadata* FillMetadataArray(
     std::multimap<grpc::string, grpc::string>* metadata) {
-  if (metadata->empty()) { return nullptr; }
-  grpc_metadata* metadata_array = (grpc_metadata*)gpr_malloc(
-      metadata->size()* sizeof(grpc_metadata));
+  if (metadata->empty()) {
+    return nullptr;
+  }
+  grpc_metadata* metadata_array =
+      (grpc_metadata*)gpr_malloc(metadata->size() * sizeof(grpc_metadata));
   size_t i = 0;
-  for (auto iter = metadata->cbegin();
-       iter != metadata->cend();
-       ++iter, ++i) {
+  for (auto iter = metadata->cbegin(); iter != metadata->cend(); ++iter, ++i) {
     metadata_array[i].key = iter->first.c_str();
     metadata_array[i].value = iter->second.c_str();
     metadata_array[i].value_length = iter->second.size();
@@ -114,7 +114,8 @@ void FillMetadataMap(grpc_metadata_array* arr,
   for (size_t i = 0; i < arr->count; i++) {
     // TODO(yangg) handle duplicates?
     metadata->insert(std::pair<grpc::string, grpc::string>(
-        arr->metadata[i].key, {arr->metadata[i].value, arr->metadata[i].value_length}));
+        arr->metadata[i].key,
+        {arr->metadata[i].value, arr->metadata[i].value_length}));
   }
   grpc_metadata_array_destroy(arr);
   grpc_metadata_array_init(arr);
@@ -133,7 +134,6 @@ void CallOpBuffer::AddRecvInitialMetadata(
   recv_initial_metadata_ = metadata;
 }
 
-
 void CallOpBuffer::AddSendInitialMetadata(ClientContext* ctx) {
   AddSendInitialMetadata(&ctx->send_initial_metadata_);
 }
@@ -146,9 +146,7 @@ void CallOpBuffer::AddRecvMessage(google::protobuf::Message *message) {
   recv_message_ = message;
 }
 
-void CallOpBuffer::AddClientSendClose() {
-  client_send_close_ = true;
-}
+void CallOpBuffer::AddClientSendClose() { client_send_close_ = true; }
 
 void CallOpBuffer::AddServerRecvClose(bool* cancelled) {
   recv_closed_ = cancelled;
@@ -270,8 +268,7 @@ void CallOpBuffer::FinalizeResult(void **tag, bool *status) {
     FillMetadataMap(&recv_trailing_metadata_arr_, recv_trailing_metadata_);
     *recv_status_ = Status(
         static_cast<StatusCode>(status_code_),
-        status_details_ ?  grpc::string(status_details_)
-                        :  grpc::string());
+        status_details_ ? grpc::string(status_details_) : grpc::string());
   }
   if (recv_closed_) {
     *recv_closed_ = cancelled_buf_ != 0;

src/cpp/common/completion_queue.cc

@@ -52,7 +52,9 @@ void CompletionQueue::Shutdown() { grpc_completion_queue_shutdown(cq_); }
 // Helper class so we can declare a unique_ptr with grpc_event
 class EventDeleter {
  public:
-  void operator()(grpc_event *ev) { if (ev) grpc_event_finish(ev); }
+  void operator()(grpc_event *ev) {
+    if (ev) grpc_event_finish(ev);
+  }
 };
 
 bool CompletionQueue::Next(void **tag, bool *ok) {

src/cpp/server/async_server_context.cc

@@ -54,8 +54,8 @@ AsyncServerContext::~AsyncServerContext() { grpc_call_destroy(call_); }
 
 void AsyncServerContext::Accept(grpc_completion_queue *cq) {
   GPR_ASSERT(grpc_call_server_accept_old(call_, cq, this) == GRPC_CALL_OK);
-  GPR_ASSERT(grpc_call_server_end_initial_metadata_old(call_, GRPC_WRITE_BUFFER_HINT) ==
-             GRPC_CALL_OK);
+  GPR_ASSERT(grpc_call_server_end_initial_metadata_old(
+                 call_, GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
 }
 
 bool AsyncServerContext::StartRead(google::protobuf::Message *request) {