clang-format

6 files changed, 81 insertions, 66 deletions

diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h
index 40dbf9e641..88056470e3 100644
--- a/include/grpc++/impl/call.h
+++ b/include/grpc++/impl/call.h
@@ -54,7 +54,8 @@ class Call;
 
 void FillMetadataMap(grpc_metadata_array* arr,
                      std::multimap<grpc::string, grpc::string>* metadata);
-grpc_metadata* FillMetadataArray(const std::multimap<grpc::string, grpc::string>& metadata);
+grpc_metadata* FillMetadataArray(
+    const std::multimap<grpc::string, grpc::string>& metadata);
 
 class CallNoOp {
  protected:
@@ -66,7 +67,8 @@ class CallOpSendInitialMetadata {
  public:
   CallOpSendInitialMetadata() : send_(false) {}
 
-  void SendInitialMetadata(const std::multimap<grpc::string, grpc::string>& metadata) {
+  void SendInitialMetadata(
+      const std::multimap<grpc::string, grpc::string>& metadata) {
     send_ = true;
     initial_metadata_count_ = metadata.size();
     initial_metadata_ = FillMetadataArray(metadata);
@@ -118,16 +120,14 @@ class CallOpRecvMessage {
  public:
   CallOpRecvMessage() : got_message(false), message_(nullptr) {}
 
-  void RecvMessage(R* message) {
-    message_ = message;
-  }
+  void RecvMessage(R* message) { message_ = message; }
 
   bool got_message;
 
  protected:
   void AddOp(grpc_op* ops, size_t* nops) {
     if (message_ == nullptr) return;
-    grpc_op *op = &ops[(*nops)++];
+    grpc_op* op = &ops[(*nops)++];
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message = &recv_buf_;
   }
@@ -137,7 +137,9 @@ class CallOpRecvMessage {
     if (recv_buf_) {
       if (*status) {
         got_message = true;
-        *status = SerializationTraits<R>::Deserialize(recv_buf_, message_, max_message_size).IsOk();
+        *status = SerializationTraits<R>::Deserialize(recv_buf_, message_,
+                                                      max_message_size)
+                      .IsOk();
       } else {
         got_message = false;
         grpc_byte_buffer_destroy(recv_buf_);
@@ -159,8 +161,10 @@ class CallOpGenericRecvMessage {
 
   template <class R>
   void RecvMessage(R* message) {
-    deserialize_ = [message](grpc_byte_buffer* buf, int max_message_size) -> Status {
-      return SerializationTraits<R>::Deserialize(buf, message, max_message_size);
+    deserialize_ = [message](grpc_byte_buffer* buf,
+                             int max_message_size) -> Status {
+      return SerializationTraits<R>::Deserialize(buf, message,
+                                                 max_message_size);
     };
   }
 
@@ -169,7 +173,7 @@ class CallOpGenericRecvMessage {
  protected:
   void AddOp(grpc_op* ops, size_t* nops) {
     if (!deserialize_) return;
-    grpc_op *op = &ops[(*nops)++];
+    grpc_op* op = &ops[(*nops)++];
     op->op = GRPC_OP_RECV_MESSAGE;
     op->data.recv_message = &recv_buf_;
   }
@@ -218,7 +222,9 @@ class CallOpServerSendStatus {
  public:
   CallOpServerSendStatus() : send_status_available_(false) {}
 
-  void ServerSendStatus(const std::multimap<grpc::string, grpc::string>& trailing_metadata, const Status& status){
+  void ServerSendStatus(
+      const std::multimap<grpc::string, grpc::string>& trailing_metadata,
+      const Status& status) {
     trailing_metadata_count_ = trailing_metadata.size();
     trailing_metadata_ = FillMetadataArray(trailing_metadata);
     send_status_available_ = true;
@@ -232,8 +238,7 @@ class CallOpServerSendStatus {
     op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
     op->data.send_status_from_server.trailing_metadata_count =
         trailing_metadata_count_;
-    op->data.send_status_from_server.trailing_metadata =
-        trailing_metadata_;
+    op->data.send_status_from_server.trailing_metadata = trailing_metadata_;
     op->data.send_status_from_server.status = send_status_code_;
     op->data.send_status_from_server.status_details =
         send_status_details_.empty() ? nullptr : send_status_details_.c_str();
@@ -280,9 +285,7 @@ class CallOpRecvInitialMetadata {
 
 class CallOpClientRecvStatus {
  public:
-  CallOpClientRecvStatus() {
-    memset(this, 0, sizeof(*this));
-  }
+  CallOpClientRecvStatus() { memset(this, 0, sizeof(*this)); }
 
   void ClientRecvStatus(ClientContext* context, Status* status) {
     recv_trailing_metadata_ = &context->trailing_metadata_;
@@ -323,7 +326,9 @@ class CallOpSetInterface : public CompletionQueueTag {
   CallOpSetInterface() : max_message_size_(0) {}
   virtual void FillOps(grpc_op* ops, size_t* nops) = 0;
 
-  void set_max_message_size(int max_message_size) { max_message_size_ = max_message_size; }
+  void set_max_message_size(int max_message_size) {
+    max_message_size_ = max_message_size;
+  }
 
  protected:
   int max_message_size_;
@@ -332,14 +337,15 @@ class CallOpSetInterface : public CompletionQueueTag {
 template <class T, int I>
 class WrapAndDerive : public T {};
 
-template <class Op1 = CallNoOp, class Op2 = CallNoOp, class Op3 = CallNoOp, class Op4 = CallNoOp, class Op5 = CallNoOp, class Op6 = CallNoOp>
-class CallOpSet : public CallOpSetInterface, 
-public WrapAndDerive<Op1, 1>, 
-public WrapAndDerive<Op2, 2>, 
-public WrapAndDerive<Op3, 3>, 
-public WrapAndDerive<Op4, 4>, 
-public WrapAndDerive<Op5, 5>, 
-public WrapAndDerive<Op6, 6> {
+template <class Op1 = CallNoOp, class Op2 = CallNoOp, class Op3 = CallNoOp,
+          class Op4 = CallNoOp, class Op5 = CallNoOp, class Op6 = CallNoOp>
+class CallOpSet : public CallOpSetInterface,
+                  public WrapAndDerive<Op1, 1>,
+                  public WrapAndDerive<Op2, 2>,
+                  public WrapAndDerive<Op3, 3>,
+                  public WrapAndDerive<Op4, 4>,
+                  public WrapAndDerive<Op5, 5>,
+                  public WrapAndDerive<Op6, 6> {
  public:
   CallOpSet() : return_tag_(this) {}
   void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE {
@@ -365,7 +371,7 @@ public WrapAndDerive<Op6, 6> {
   void set_output_tag(void* return_tag) { return_tag_ = return_tag; }
 
  private:
-  void *return_tag_;
+  void* return_tag_;
 };
 
 #if 0
@@ -444,11 +450,15 @@ class CallOpBuffer : public CompletionQueueTag {
 #endif
 
 // SneakyCallOpBuffer does not post completions to the completion queue
-template <class Op1 = CallNoOp, class Op2 = CallNoOp, class Op3 = CallNoOp, class Op4 = CallNoOp, class Op5 = CallNoOp, class Op6 = CallNoOp>
-class SneakyCallOpSet GRPC_FINAL : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> {
+template <class Op1 = CallNoOp, class Op2 = CallNoOp, class Op3 = CallNoOp,
+          class Op4 = CallNoOp, class Op5 = CallNoOp, class Op6 = CallNoOp>
+class SneakyCallOpSet GRPC_FINAL
+    : public CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6> {
  public:
   bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
-    return CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6>::FinalizeResult(tag, status) && false;
+    return CallOpSet<Op1, Op2, Op3, Op4, Op5, Op6>::FinalizeResult(tag,
+                                                                   status) &&
+           false;
   }
 };
 
diff --git a/include/grpc++/impl/client_unary_call.h b/include/grpc++/impl/client_unary_call.h
index 5e37e63c6d..c1832f9eb8 100644
--- a/include/grpc++/impl/client_unary_call.h
+++ b/include/grpc++/impl/client_unary_call.h
@@ -49,18 +49,13 @@ class Status;
 // Wrapper that performs a blocking unary call
 template <class InputMessage, class OutputMessage>
 Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
-                         ClientContext* context,
-                         const InputMessage& request,
+                         ClientContext* context, const InputMessage& request,
                          OutputMessage* result) {
   CompletionQueue cq;
   Call call(channel->CreateCall(method, context, &cq));
-  CallOpSet<
-  		CallOpSendInitialMetadata, 
-  		CallOpSendMessage, 
-  		CallOpRecvInitialMetadata, 
-  		CallOpRecvMessage<OutputMessage>, 
-  		CallOpClientSendClose, 
-  		CallOpClientRecvStatus> ops;
+  CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
+            CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>,
+            CallOpClientSendClose, CallOpClientRecvStatus> ops;
   Status status;
   ops.SendInitialMetadata(context->send_initial_metadata_);
   if (!ops.SendMessage(request)) {
diff --git a/include/grpc++/impl/proto_utils.h b/include/grpc++/impl/proto_utils.h
index 1a0cc31a8a..ee19859198 100644
--- a/include/grpc++/impl/proto_utils.h
+++ b/include/grpc++/impl/proto_utils.h
@@ -55,14 +55,18 @@ Status DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg,
                         int max_message_size);
 
 template <class T>
-class SerializationTraits<T, typename std::enable_if<std::is_base_of<grpc::protobuf::Message, T>::value>::type> {
+class SerializationTraits<T, typename std::enable_if<std::is_base_of<
+                                 grpc::protobuf::Message, T>::value>::type> {
  public:
- 	static bool Serialize(const grpc::protobuf::Message& msg, grpc_byte_buffer** buffer) {
- 		return SerializeProto(msg, buffer);
- 	}
- 	static Status Deserialize(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, int max_message_size) {
- 		return DeserializeProto(buffer, msg, max_message_size);
- 	}
+  static bool Serialize(const grpc::protobuf::Message& msg,
+                        grpc_byte_buffer** buffer) {
+    return SerializeProto(msg, buffer);
+  }
+  static Status Deserialize(grpc_byte_buffer* buffer,
+                            grpc::protobuf::Message* msg,
+                            int max_message_size) {
+    return DeserializeProto(buffer, msg, max_message_size);
+  }
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/impl/rpc_service_method.h b/include/grpc++/impl/rpc_service_method.h
index cd31b22323..1bf39fca3b 100644
--- a/include/grpc++/impl/rpc_service_method.h
+++ b/include/grpc++/impl/rpc_service_method.h
@@ -55,9 +55,12 @@ class MethodHandler {
  public:
   virtual ~MethodHandler() {}
   struct HandlerParameter {
-    HandlerParameter(Call* c, ServerContext* context,
-                     grpc_byte_buffer* req, int max_size)
-        : call(c), server_context(context), request(req), max_message_size(max_size) {}
+    HandlerParameter(Call* c, ServerContext* context, grpc_byte_buffer* req,
+                     int max_size)
+        : call(c),
+          server_context(context),
+          request(req),
+          max_message_size(max_size) {}
     Call* call;
     ServerContext* server_context;
     // Handler required to grpc_byte_buffer_destroy this
@@ -79,14 +82,16 @@ class RpcMethodHandler : public MethodHandler {
 
   void RunHandler(const HandlerParameter& param) GRPC_FINAL {
     RequestType req;
-    Status status = SerializationTraits<RequestType>::Deserialize(param.request, &req, param.max_message_size);
+    Status status = SerializationTraits<RequestType>::Deserialize(
+        param.request, &req, param.max_message_size);
     ResponseType rsp;
     if (status.IsOk()) {
       status = func_(service_, param.server_context, &req, &rsp);
     }
 
     GPR_ASSERT(!param.server_context->sent_initial_metadata_);
-    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, CallOpServerSendStatus> ops;
+    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
+              CallOpServerSendStatus> ops;
     ops.SendInitialMetadata(param.server_context->initial_metadata_);
     if (status.IsOk()) {
       if (!ops.SendMessage(rsp)) {
@@ -122,7 +127,8 @@ class ClientStreamingHandler : public MethodHandler {
     Status status = func_(service_, param.server_context, &reader, &rsp);
 
     GPR_ASSERT(!param.server_context->sent_initial_metadata_);
-    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, CallOpServerSendStatus> ops;
+    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
+              CallOpServerSendStatus> ops;
     ops.SendInitialMetadata(param.server_context->initial_metadata_);
     if (status.IsOk()) {
       if (!ops.SendMessage(rsp)) {
@@ -152,7 +158,8 @@ class ServerStreamingHandler : public MethodHandler {
 
   void RunHandler(const HandlerParameter& param) GRPC_FINAL {
     RequestType req;
-    Status status = SerializationTraits<RequestType>::Deserialize(param.request, &req, param.max_message_size);
+    Status status = SerializationTraits<RequestType>::Deserialize(
+        param.request, &req, param.max_message_size);
 
     if (status.IsOk()) {
       ServerWriter<ResponseType> writer(param.call, param.server_context);
@@ -211,8 +218,7 @@ class RpcServiceMethod : public RpcMethod {
   // Takes ownership of the handler
   RpcServiceMethod(const char* name, RpcMethod::RpcType type,
                    MethodHandler* handler)
-      : RpcMethod(name, type, nullptr),
-        handler_(handler) {}
+      : RpcMethod(name, type, nullptr), handler_(handler) {}
 
   MethodHandler* handler() { return handler_.get(); }
 
diff --git a/include/grpc++/impl/serialization_traits.h b/include/grpc++/impl/serialization_traits.h
index 4648bbfc33..e4f086e08d 100644
--- a/include/grpc++/impl/serialization_traits.h
+++ b/include/grpc++/impl/serialization_traits.h
@@ -38,9 +38,10 @@ struct grpc_byte_buffer;
 
 namespace grpc {
 
-template <class Message, class UnusedButHereForPartialTemplateSpecialization = void>
+template <class Message,
+          class UnusedButHereForPartialTemplateSpecialization = void>
 class SerializationTraits;
 
 }  // namespace grpc
 
-#endif // GRPCXX_IMPL_SERIALIZATION_TRAITS_H
+#endif  // GRPCXX_IMPL_SERIALIZATION_TRAITS_H
diff --git a/include/grpc++/impl/service_type.h b/include/grpc++/impl/service_type.h
index af21d9b8cf..8f9f38f193 100644
--- a/include/grpc++/impl/service_type.h
+++ b/include/grpc++/impl/service_type.h
@@ -77,21 +77,20 @@ class AsynchronousService {
 
  protected:
   template <class Message>
-  void RequestAsyncUnary(int index, ServerContext* context,
-                         Message* request,
+  void RequestAsyncUnary(int index, ServerContext* context, Message* request,
                          ServerAsyncStreamingInterface* stream,
                          CompletionQueue* call_cq,
                          ServerCompletionQueue* notification_cq, void* tag) {
-    server_->RequestAsyncCall(request_args_[index], context,
-                                     stream, call_cq, notification_cq, tag, request);
+    server_->RequestAsyncCall(request_args_[index], context, stream, call_cq,
+                              notification_cq, tag, request);
   }
   void RequestClientStreaming(int index, ServerContext* context,
                               ServerAsyncStreamingInterface* stream,
                               CompletionQueue* call_cq,
                               ServerCompletionQueue* notification_cq,
                               void* tag) {
-    server_->RequestAsyncCall(request_args_[index], context, 
-                                     stream, call_cq, notification_cq, tag);
+    server_->RequestAsyncCall(request_args_[index], context, stream, call_cq,
+                              notification_cq, tag);
   }
   template <class Message>
   void RequestServerStreaming(int index, ServerContext* context,
@@ -100,15 +99,15 @@ class AsynchronousService {
                               CompletionQueue* call_cq,
                               ServerCompletionQueue* notification_cq,
                               void* tag) {
-    server_->RequestAsyncCall(request_args_[index], context, 
-                                     stream, call_cq, notification_cq, tag, request);
+    server_->RequestAsyncCall(request_args_[index], context, stream, call_cq,
+                              notification_cq, tag, request);
   }
   void RequestBidiStreaming(int index, ServerContext* context,
                             ServerAsyncStreamingInterface* stream,
                             CompletionQueue* call_cq,
                             ServerCompletionQueue* notification_cq, void* tag) {
-    server_->RequestAsyncCall(request_args_[index], context, 
-                                     stream, call_cq, notification_cq, tag);
+    server_->RequestAsyncCall(request_args_[index], context, stream, call_cq,
+                              notification_cq, tag);
   }
 
  private: