third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/java/java_service.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 42 matching lines @@
 
 // ===================================================================
 ImmutableServiceGenerator::ImmutableServiceGenerator(
     const ServiceDescriptor* descriptor, Context* context)
     : ServiceGenerator(descriptor), context_(context),
     name_resolver_(context->GetNameResolver()) {}
 
 ImmutableServiceGenerator::~ImmutableServiceGenerator() {}
 
 void ImmutableServiceGenerator::Generate(io::Printer* printer) {
-  bool is_own_file =
-    MultipleJavaFiles(descriptor_->file(), /* immutable = */ true);
+  bool is_own_file = IsOwnFile(descriptor_, /* immutable = */ true);
   WriteServiceDocComment(printer, descriptor_);
+  MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
+                                /* immutable = */ true);
   printer->Print(
     "public $static$ abstract class $classname$\n"
     "    implements com.google.protobuf.Service {\n",
     "static", is_own_file ? "" : "static",
     "classname", descriptor_->name());
   printer->Indent();
 
   printer->Print(
     "protected $classname$() {}\n\n",
     "classname", descriptor_->name());
@@ skipping 100 matching lines @@
 
 void ImmutableServiceGenerator::GenerateAbstractMethods(io::Printer* printer) {
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
     WriteMethodDocComment(printer, method);
     GenerateMethodSignature(printer, method, IS_ABSTRACT);
     printer->Print(";\n\n");
   }
 }
 
+string ImmutableServiceGenerator::GetOutput(const MethodDescriptor* method) {
+  return name_resolver_->GetImmutableClassName(method->output_type());
+}
+
 void ImmutableServiceGenerator::GenerateCallMethod(io::Printer* printer) {
   printer->Print(
     "\n"
     "public final void callMethod(\n"
     "    com.google.protobuf.Descriptors.MethodDescriptor method,\n"
     "    com.google.protobuf.RpcController controller,\n"
     "    com.google.protobuf.Message request,\n"
     "    com.google.protobuf.RpcCallback<\n"
     "      com.google.protobuf.Message> done) {\n"
     "  if (method.getService() != getDescriptor()) {\n"
     "    throw new java.lang.IllegalArgumentException(\n"
     "      \"Service.callMethod() given method descriptor for wrong \" +\n"
     "      \"service type.\");\n"
     "  }\n"
     "  switch(method.getIndex()) {\n");
   printer->Indent();
   printer->Indent();
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["index"] = SimpleItoa(i);
     vars["method"] = UnderscoresToCamelCase(method);
     vars["input"] = name_resolver_->GetImmutableClassName(
         method->input_type());
-    vars["output"] = name_resolver_->GetImmutableClassName(
-        method->output_type());
+    vars["output"] = GetOutput(method);
     printer->Print(vars,
       "case $index$:\n"
       "  this.$method$(controller, ($input$)request,\n"
       "    com.google.protobuf.RpcUtil.<$output$>specializeCallback(\n"
       "      done));\n"
       "  return;\n");
   }
 
   printer->Print(
     "default:\n"
@@ skipping 21 matching lines @@
     "    throw new java.lang.IllegalArgumentException(\n"
     "      \"Service.callBlockingMethod() given method descriptor for \" +\n"
     "      \"wrong service type.\");\n"
     "  }\n"
     "  switch(method.getIndex()) {\n");
   printer->Indent();
   printer->Indent();
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["index"] = SimpleItoa(i);
     vars["method"] = UnderscoresToCamelCase(method);
     vars["input"] = name_resolver_->GetImmutableClassName(
         method->input_type());
-    vars["output"] = name_resolver_->GetImmutableClassName(
-        method->output_type());
+    vars["output"] = GetOutput(method);
     printer->Print(vars,
       "case $index$:\n"
       "  return impl.$method$(controller, ($input$)request);\n");
   }
 
   printer->Print(
     "default:\n"
     "  throw new java.lang.AssertionError(\"Can't get here.\");\n");
 
   printer->Outdent();
@@ skipping 20 matching lines @@
     "      \"Service.get$request_or_response$Prototype() given method \" +\n"
     "      \"descriptor for wrong service type.\");\n"
     "  }\n"
     "  switch(method.getIndex()) {\n",
     "request_or_response", (which == REQUEST) ? "Request" : "Response");
   printer->Indent();
   printer->Indent();
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["index"] = SimpleItoa(i);
     vars["type"] = name_resolver_->GetImmutableClassName(
       (which == REQUEST) ? method->input_type() : method->output_type());
     printer->Print(vars,
       "case $index$:\n"
       "  return $type$.getDefaultInstance();\n");
   }
 
   printer->Print(
     "default:\n"
@@ skipping 31 matching lines @@
     "  return channel;\n"
     "}\n");
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
     printer->Print("\n");
     GenerateMethodSignature(printer, method, IS_CONCRETE);
     printer->Print(" {\n");
     printer->Indent();
 
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["index"] = SimpleItoa(i);
-    vars["output"] = name_resolver_->GetImmutableClassName(
-        method->output_type());
+    vars["output"] = GetOutput(method);
     printer->Print(vars,
       "channel.callMethod(\n"
       "  getDescriptor().getMethods().get($index$),\n"
       "  controller,\n"
       "  request,\n"
       "  $output$.getDefaultInstance(),\n"
       "  com.google.protobuf.RpcUtil.generalizeCallback(\n"
       "    done,\n"
       "    $output$.class,\n"
       "    $output$.getDefaultInstance()));\n");
@@ skipping 41 matching lines @@
     "}\n"
     "\n"
     "private final com.google.protobuf.BlockingRpcChannel channel;\n");
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
     GenerateBlockingMethodSignature(printer, method);
     printer->Print(" {\n");
     printer->Indent();
 
-    map<string, string> vars;
+    std::map<string, string> vars;
     vars["index"] = SimpleItoa(i);
-    vars["output"] = name_resolver_->GetImmutableClassName(
-        method->output_type());
+    vars["output"] = GetOutput(method);
     printer->Print(vars,
       "return ($output$) channel.callBlockingMethod(\n"
       "  getDescriptor().getMethods().get($index$),\n"
       "  controller,\n"
       "  request,\n"
       "  $output$.getDefaultInstance());\n");
 
     printer->Outdent();
     printer->Print(
       "}\n"
       "\n");
   }
 
   printer->Outdent();
   printer->Print("}\n");
 }
 
 void ImmutableServiceGenerator::GenerateMethodSignature(io::Printer* printer,
                                                const MethodDescriptor* method,
                                                IsAbstract is_abstract) {
-  map<string, string> vars;
+  std::map<string, string> vars;
   vars["name"] = UnderscoresToCamelCase(method);
   vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
-  vars["output"] = name_resolver_->GetImmutableClassName(method->output_type());
+  vars["output"] = GetOutput(method);
   vars["abstract"] = (is_abstract == IS_ABSTRACT) ? "abstract" : "";
   printer->Print(vars,
     "public $abstract$ void $name$(\n"
     "    com.google.protobuf.RpcController controller,\n"
     "    $input$ request,\n"
     "    com.google.protobuf.RpcCallback<$output$> done)");
 }
 
 void ImmutableServiceGenerator::GenerateBlockingMethodSignature(
     io::Printer* printer,
     const MethodDescriptor* method) {
-  map<string, string> vars;
+  std::map<string, string> vars;
   vars["method"] = UnderscoresToCamelCase(method);
   vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
-  vars["output"] = name_resolver_->GetImmutableClassName(method->output_type());
+  vars["output"] = GetOutput(method);
   printer->Print(vars,
     "\n"
     "public $output$ $method$(\n"
     "    com.google.protobuf.RpcController controller,\n"
     "    $input$ request)\n"
     "    throws com.google.protobuf.ServiceException");
 }
 
 }  // namespace java
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google