/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/compiler/java/java_service.cc
C++ | 444 lines | 349 code | 57 blank | 38 comment | 11 complexity | 34f6d8971049661d25b888b88a360ced MD5 | raw file
1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// http://code.google.com/p/protobuf/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// Author: kenton@google.com (Kenton Varda) 32// Based on original Protocol Buffers design by 33// Sanjay Ghemawat, Jeff Dean, and others. 34 35#include <google/protobuf/compiler/java/java_service.h> 36#include <google/protobuf/compiler/java/java_helpers.h> 37#include <google/protobuf/io/printer.h> 38#include <google/protobuf/descriptor.pb.h> 39#include <google/protobuf/stubs/strutil.h> 40 41namespace google { 42namespace protobuf { 43namespace compiler { 44namespace java { 45 46ServiceGenerator::ServiceGenerator(const ServiceDescriptor* descriptor) 47 : descriptor_(descriptor) {} 48 49ServiceGenerator::~ServiceGenerator() {} 50 51void ServiceGenerator::Generate(io::Printer* printer) { 52 bool is_own_file = descriptor_->file()->options().java_multiple_files(); 53 printer->Print( 54 "public $static$ abstract class $classname$\n" 55 " implements com.google.protobuf.Service {\n", 56 "static", is_own_file ? "" : "static", 57 "classname", descriptor_->name()); 58 printer->Indent(); 59 60 printer->Print( 61 "protected $classname$() {}\n\n", 62 "classname", descriptor_->name()); 63 64 GenerateInterface(printer); 65 66 GenerateNewReflectiveServiceMethod(printer); 67 GenerateNewReflectiveBlockingServiceMethod(printer); 68 69 GenerateAbstractMethods(printer); 70 71 // Generate getDescriptor() and getDescriptorForType(). 72 printer->Print( 73 "public static final\n" 74 " com.google.protobuf.Descriptors.ServiceDescriptor\n" 75 " getDescriptor() {\n" 76 " return $file$.getDescriptor().getServices().get($index$);\n" 77 "}\n", 78 "file", ClassName(descriptor_->file()), 79 "index", SimpleItoa(descriptor_->index())); 80 GenerateGetDescriptorForType(printer); 81 82 // Generate more stuff. 83 GenerateCallMethod(printer); 84 GenerateGetPrototype(REQUEST, printer); 85 GenerateGetPrototype(RESPONSE, printer); 86 GenerateStub(printer); 87 GenerateBlockingStub(printer); 88 89 printer->Outdent(); 90 printer->Print("}\n\n"); 91} 92 93void ServiceGenerator::GenerateGetDescriptorForType(io::Printer* printer) { 94 printer->Print( 95 "public final com.google.protobuf.Descriptors.ServiceDescriptor\n" 96 " getDescriptorForType() {\n" 97 " return getDescriptor();\n" 98 "}\n"); 99} 100 101void ServiceGenerator::GenerateInterface(io::Printer* printer) { 102 printer->Print("public interface Interface {\n"); 103 printer->Indent(); 104 GenerateAbstractMethods(printer); 105 printer->Outdent(); 106 printer->Print("}\n\n"); 107} 108 109void ServiceGenerator::GenerateNewReflectiveServiceMethod( 110 io::Printer* printer) { 111 printer->Print( 112 "public static com.google.protobuf.Service newReflectiveService(\n" 113 " final Interface impl) {\n" 114 " return new $classname$() {\n", 115 "classname", descriptor_->name()); 116 printer->Indent(); 117 printer->Indent(); 118 119 for (int i = 0; i < descriptor_->method_count(); i++) { 120 const MethodDescriptor* method = descriptor_->method(i); 121 printer->Print("@java.lang.Override\n"); 122 GenerateMethodSignature(printer, method, IS_CONCRETE); 123 printer->Print( 124 " {\n" 125 " impl.$method$(controller, request, done);\n" 126 "}\n\n", 127 "method", UnderscoresToCamelCase(method)); 128 } 129 130 printer->Outdent(); 131 printer->Print("};\n"); 132 printer->Outdent(); 133 printer->Print("}\n\n"); 134} 135 136void ServiceGenerator::GenerateNewReflectiveBlockingServiceMethod( 137 io::Printer* printer) { 138 printer->Print( 139 "public static com.google.protobuf.BlockingService\n" 140 " newReflectiveBlockingService(final BlockingInterface impl) {\n" 141 " return new com.google.protobuf.BlockingService() {\n"); 142 printer->Indent(); 143 printer->Indent(); 144 145 GenerateGetDescriptorForType(printer); 146 147 GenerateCallBlockingMethod(printer); 148 GenerateGetPrototype(REQUEST, printer); 149 GenerateGetPrototype(RESPONSE, printer); 150 151 printer->Outdent(); 152 printer->Print("};\n"); 153 printer->Outdent(); 154 printer->Print("}\n\n"); 155} 156 157void ServiceGenerator::GenerateAbstractMethods(io::Printer* printer) { 158 for (int i = 0; i < descriptor_->method_count(); i++) { 159 const MethodDescriptor* method = descriptor_->method(i); 160 GenerateMethodSignature(printer, method, IS_ABSTRACT); 161 printer->Print(";\n\n"); 162 } 163} 164 165void ServiceGenerator::GenerateCallMethod(io::Printer* printer) { 166 printer->Print( 167 "\n" 168 "public final void callMethod(\n" 169 " com.google.protobuf.Descriptors.MethodDescriptor method,\n" 170 " com.google.protobuf.RpcController controller,\n" 171 " com.google.protobuf.Message request,\n" 172 " com.google.protobuf.RpcCallback<\n" 173 " com.google.protobuf.Message> done) {\n" 174 " if (method.getService() != getDescriptor()) {\n" 175 " throw new java.lang.IllegalArgumentException(\n" 176 " \"Service.callMethod() given method descriptor for wrong \" +\n" 177 " \"service type.\");\n" 178 " }\n" 179 " switch(method.getIndex()) {\n"); 180 printer->Indent(); 181 printer->Indent(); 182 183 for (int i = 0; i < descriptor_->method_count(); i++) { 184 const MethodDescriptor* method = descriptor_->method(i); 185 map<string, string> vars; 186 vars["index"] = SimpleItoa(i); 187 vars["method"] = UnderscoresToCamelCase(method); 188 vars["input"] = ClassName(method->input_type()); 189 vars["output"] = ClassName(method->output_type()); 190 printer->Print(vars, 191 "case $index$:\n" 192 " this.$method$(controller, ($input$)request,\n" 193 " com.google.protobuf.RpcUtil.<$output$>specializeCallback(\n" 194 " done));\n" 195 " return;\n"); 196 } 197 198 printer->Print( 199 "default:\n" 200 " throw new java.lang.AssertionError(\"Can't get here.\");\n"); 201 202 printer->Outdent(); 203 printer->Outdent(); 204 205 printer->Print( 206 " }\n" 207 "}\n" 208 "\n"); 209} 210 211void ServiceGenerator::GenerateCallBlockingMethod(io::Printer* printer) { 212 printer->Print( 213 "\n" 214 "public final com.google.protobuf.Message callBlockingMethod(\n" 215 " com.google.protobuf.Descriptors.MethodDescriptor method,\n" 216 " com.google.protobuf.RpcController controller,\n" 217 " com.google.protobuf.Message request)\n" 218 " throws com.google.protobuf.ServiceException {\n" 219 " if (method.getService() != getDescriptor()) {\n" 220 " throw new java.lang.IllegalArgumentException(\n" 221 " \"Service.callBlockingMethod() given method descriptor for \" +\n" 222 " \"wrong service type.\");\n" 223 " }\n" 224 " switch(method.getIndex()) {\n"); 225 printer->Indent(); 226 printer->Indent(); 227 228 for (int i = 0; i < descriptor_->method_count(); i++) { 229 const MethodDescriptor* method = descriptor_->method(i); 230 map<string, string> vars; 231 vars["index"] = SimpleItoa(i); 232 vars["method"] = UnderscoresToCamelCase(method); 233 vars["input"] = ClassName(method->input_type()); 234 vars["output"] = ClassName(method->output_type()); 235 printer->Print(vars, 236 "case $index$:\n" 237 " return impl.$method$(controller, ($input$)request);\n"); 238 } 239 240 printer->Print( 241 "default:\n" 242 " throw new java.lang.AssertionError(\"Can't get here.\");\n"); 243 244 printer->Outdent(); 245 printer->Outdent(); 246 247 printer->Print( 248 " }\n" 249 "}\n" 250 "\n"); 251} 252 253void ServiceGenerator::GenerateGetPrototype(RequestOrResponse which, 254 io::Printer* printer) { 255 /* 256 * TODO(cpovirk): The exception message says "Service.foo" when it may be 257 * "BlockingService.foo." Consider fixing. 258 */ 259 printer->Print( 260 "public final com.google.protobuf.Message\n" 261 " get$request_or_response$Prototype(\n" 262 " com.google.protobuf.Descriptors.MethodDescriptor method) {\n" 263 " if (method.getService() != getDescriptor()) {\n" 264 " throw new java.lang.IllegalArgumentException(\n" 265 " \"Service.get$request_or_response$Prototype() given method \" +\n" 266 " \"descriptor for wrong service type.\");\n" 267 " }\n" 268 " switch(method.getIndex()) {\n", 269 "request_or_response", (which == REQUEST) ? "Request" : "Response"); 270 printer->Indent(); 271 printer->Indent(); 272 273 for (int i = 0; i < descriptor_->method_count(); i++) { 274 const MethodDescriptor* method = descriptor_->method(i); 275 map<string, string> vars; 276 vars["index"] = SimpleItoa(i); 277 vars["type"] = ClassName( 278 (which == REQUEST) ? method->input_type() : method->output_type()); 279 printer->Print(vars, 280 "case $index$:\n" 281 " return $type$.getDefaultInstance();\n"); 282 } 283 284 printer->Print( 285 "default:\n" 286 " throw new java.lang.AssertionError(\"Can't get here.\");\n"); 287 288 printer->Outdent(); 289 printer->Outdent(); 290 291 printer->Print( 292 " }\n" 293 "}\n" 294 "\n"); 295} 296 297void ServiceGenerator::GenerateStub(io::Printer* printer) { 298 printer->Print( 299 "public static Stub newStub(\n" 300 " com.google.protobuf.RpcChannel channel) {\n" 301 " return new Stub(channel);\n" 302 "}\n" 303 "\n" 304 "public static final class Stub extends $classname$ implements Interface {" 305 "\n", 306 "classname", ClassName(descriptor_)); 307 printer->Indent(); 308 309 printer->Print( 310 "private Stub(com.google.protobuf.RpcChannel channel) {\n" 311 " this.channel = channel;\n" 312 "}\n" 313 "\n" 314 "private final com.google.protobuf.RpcChannel channel;\n" 315 "\n" 316 "public com.google.protobuf.RpcChannel getChannel() {\n" 317 " return channel;\n" 318 "}\n"); 319 320 for (int i = 0; i < descriptor_->method_count(); i++) { 321 const MethodDescriptor* method = descriptor_->method(i); 322 printer->Print("\n"); 323 GenerateMethodSignature(printer, method, IS_CONCRETE); 324 printer->Print(" {\n"); 325 printer->Indent(); 326 327 map<string, string> vars; 328 vars["index"] = SimpleItoa(i); 329 vars["output"] = ClassName(method->output_type()); 330 printer->Print(vars, 331 "channel.callMethod(\n" 332 " getDescriptor().getMethods().get($index$),\n" 333 " controller,\n" 334 " request,\n" 335 " $output$.getDefaultInstance(),\n" 336 " com.google.protobuf.RpcUtil.generalizeCallback(\n" 337 " done,\n" 338 " $output$.class,\n" 339 " $output$.getDefaultInstance()));\n"); 340 341 printer->Outdent(); 342 printer->Print("}\n"); 343 } 344 345 printer->Outdent(); 346 printer->Print( 347 "}\n" 348 "\n"); 349} 350 351void ServiceGenerator::GenerateBlockingStub(io::Printer* printer) { 352 printer->Print( 353 "public static BlockingInterface newBlockingStub(\n" 354 " com.google.protobuf.BlockingRpcChannel channel) {\n" 355 " return new BlockingStub(channel);\n" 356 "}\n" 357 "\n"); 358 359 printer->Print( 360 "public interface BlockingInterface {"); 361 printer->Indent(); 362 363 for (int i = 0; i < descriptor_->method_count(); i++) { 364 const MethodDescriptor* method = descriptor_->method(i); 365 GenerateBlockingMethodSignature(printer, method); 366 printer->Print(";\n"); 367 } 368 369 printer->Outdent(); 370 printer->Print( 371 "}\n" 372 "\n"); 373 374 printer->Print( 375 "private static final class BlockingStub implements BlockingInterface {\n"); 376 printer->Indent(); 377 378 printer->Print( 379 "private BlockingStub(com.google.protobuf.BlockingRpcChannel channel) {\n" 380 " this.channel = channel;\n" 381 "}\n" 382 "\n" 383 "private final com.google.protobuf.BlockingRpcChannel channel;\n"); 384 385 for (int i = 0; i < descriptor_->method_count(); i++) { 386 const MethodDescriptor* method = descriptor_->method(i); 387 GenerateBlockingMethodSignature(printer, method); 388 printer->Print(" {\n"); 389 printer->Indent(); 390 391 map<string, string> vars; 392 vars["index"] = SimpleItoa(i); 393 vars["output"] = ClassName(method->output_type()); 394 printer->Print(vars, 395 "return ($output$) channel.callBlockingMethod(\n" 396 " getDescriptor().getMethods().get($index$),\n" 397 " controller,\n" 398 " request,\n" 399 " $output$.getDefaultInstance());\n"); 400 401 printer->Outdent(); 402 printer->Print( 403 "}\n" 404 "\n"); 405 } 406 407 printer->Outdent(); 408 printer->Print("}\n"); 409} 410 411void ServiceGenerator::GenerateMethodSignature(io::Printer* printer, 412 const MethodDescriptor* method, 413 IsAbstract is_abstract) { 414 map<string, string> vars; 415 vars["name"] = UnderscoresToCamelCase(method); 416 vars["input"] = ClassName(method->input_type()); 417 vars["output"] = ClassName(method->output_type()); 418 vars["abstract"] = (is_abstract == IS_ABSTRACT) ? "abstract" : ""; 419 printer->Print(vars, 420 "public $abstract$ void $name$(\n" 421 " com.google.protobuf.RpcController controller,\n" 422 " $input$ request,\n" 423 " com.google.protobuf.RpcCallback<$output$> done)"); 424} 425 426void ServiceGenerator::GenerateBlockingMethodSignature( 427 io::Printer* printer, 428 const MethodDescriptor* method) { 429 map<string, string> vars; 430 vars["method"] = UnderscoresToCamelCase(method); 431 vars["input"] = ClassName(method->input_type()); 432 vars["output"] = ClassName(method->output_type()); 433 printer->Print(vars, 434 "\n" 435 "public $output$ $method$(\n" 436 " com.google.protobuf.RpcController controller,\n" 437 " $input$ request)\n" 438 " throws com.google.protobuf.ServiceException"); 439} 440 441} // namespace java 442} // namespace compiler 443} // namespace protobuf 444} // namespace google