src/compiler/cpp_generator.cc
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #include "src/compiler/cpp_generator.h"
20 
21 #include <map>
22 #include <sstream>
23 
24 namespace grpc_cpp_generator {
25 namespace {
26 
27 template <class T>
28 std::string as_string(T x) {
29  std::ostringstream out;
30  out << x;
31  return out.str();
32 }
33 
34 inline bool ClientOnlyStreaming(const grpc_generator::Method* method) {
35  return method->ClientStreaming() && !method->ServerStreaming();
36 }
37 
38 inline bool ServerOnlyStreaming(const grpc_generator::Method* method) {
39  return !method->ClientStreaming() && method->ServerStreaming();
40 }
41 
42 std::string FilenameIdentifier(const std::string& filename) {
43  std::string result;
44  for (unsigned i = 0; i < filename.size(); i++) {
45  char c = filename[i];
46  if (isalnum(c)) {
47  result.push_back(c);
48  } else {
49  static char hex[] = "0123456789abcdef";
50  result.push_back('_');
51  result.push_back(hex[(c >> 4) & 0xf]);
52  result.push_back(hex[c & 0xf]);
53  }
54  }
55  return result;
56 }
57 } // namespace
58 
59 template <class T, size_t N>
60 T* array_end(T (&array)[N]) {
61  return array + N;
62 }
63 
64 void PrintIncludes(grpc_generator::Printer* printer,
65  const std::vector<std::string>& headers,
66  bool use_system_headers, const std::string& search_path) {
67  std::map<std::string, std::string> vars;
68 
69  vars["l"] = use_system_headers ? '<' : '"';
70  vars["r"] = use_system_headers ? '>' : '"';
71 
72  if (!search_path.empty()) {
73  vars["l"] += search_path;
74  if (search_path[search_path.size() - 1] != '/') {
75  vars["l"] += '/';
76  }
77  }
78 
79  for (auto i = headers.begin(); i != headers.end(); i++) {
80  vars["h"] = *i;
81  printer->Print(vars, "#include $l$$h$$r$\n");
82  }
83 }
84 
85 std::string GetHeaderPrologue(grpc_generator::File* file,
86  const Parameters& params) {
87  std::string output;
88  {
89  // Scope the output stream so it closes and finalizes output to the string.
90  auto printer = file->CreatePrinter(&output);
91  std::map<std::string, std::string> vars;
92 
93  vars["filename"] = file->filename();
94  vars["filename_identifier"] = FilenameIdentifier(file->filename());
95  vars["filename_base"] = file->filename_without_ext();
96  vars["message_header_ext"] = params.message_header_extension.empty()
97  ? kCppGeneratorMessageHeaderExt
98  : params.message_header_extension;
99 
100  printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
101  printer->Print(vars,
102  "// If you make any local change, they will be lost.\n");
103  printer->Print(vars, "// source: $filename$\n");
104  std::string leading_comments = file->GetLeadingComments("//");
105  if (!leading_comments.empty()) {
106  printer->Print(vars, "// Original file comments:\n");
107  printer->PrintRaw(leading_comments.c_str());
108  }
109  printer->Print(vars, "#ifndef GRPC_$filename_identifier$__INCLUDED\n");
110  printer->Print(vars, "#define GRPC_$filename_identifier$__INCLUDED\n");
111  printer->Print(vars, "\n");
112  printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
113  printer->Print(vars, file->additional_headers().c_str());
114  printer->Print(vars, "\n");
115  }
116  return output;
117 }
118 
119 // Convert from "a/b/c.proto" to "#include \"a/b/c$message_header_ext$\"\n"
120 std::string ImportInludeFromProtoName(const std::string& proto_name) {
121  return std::string("#include \"") +
122  proto_name.substr(0, proto_name.size() - 6) +
123  std::string("$message_header_ext$\"\n");
124 }
125 
126 std::string GetHeaderIncludes(grpc_generator::File* file,
127  const Parameters& params) {
128  std::string output;
129  {
130  // Scope the output stream so it closes and finalizes output to the string.
131  auto printer = file->CreatePrinter(&output);
132  std::map<std::string, std::string> vars;
133 
134  if (!params.additional_header_includes.empty()) {
135  PrintIncludes(printer.get(), params.additional_header_includes, false,
136  "");
137  }
138  static const char* headers_strs[] = {
139  "functional",
140  "grpcpp/impl/codegen/async_generic_service.h",
141  "grpcpp/impl/codegen/async_stream.h",
142  "grpcpp/impl/codegen/async_unary_call.h",
143  "grpcpp/impl/codegen/client_callback.h",
144  "grpcpp/impl/codegen/client_context.h",
145  "grpcpp/impl/codegen/completion_queue.h",
146  "grpcpp/impl/codegen/message_allocator.h",
147  "grpcpp/impl/codegen/method_handler.h",
148  "grpcpp/impl/codegen/proto_utils.h",
149  "grpcpp/impl/codegen/rpc_method.h",
150  "grpcpp/impl/codegen/server_callback.h",
151  "grpcpp/impl/codegen/server_callback_handlers.h",
152  "grpcpp/impl/codegen/server_context.h",
153  "grpcpp/impl/codegen/service_type.h",
154  "grpcpp/impl/codegen/status.h",
155  "grpcpp/impl/codegen/stub_options.h",
156  "grpcpp/impl/codegen/sync_stream.h",
157  };
158  std::vector<std::string> headers(headers_strs, array_end(headers_strs));
159  PrintIncludes(printer.get(), headers, params.use_system_headers,
160  params.grpc_search_path);
161  printer->Print(vars, "\n");
162 
163  vars["message_header_ext"] = params.message_header_extension.empty()
164  ? kCppGeneratorMessageHeaderExt
165  : params.message_header_extension;
166 
167  if (params.include_import_headers) {
168  const std::vector<std::string> import_names = file->GetImportNames();
169  for (const auto& import_name : import_names) {
170  const std::string include_name = ImportInludeFromProtoName(import_name);
171  printer->Print(vars, include_name.c_str());
172  }
173  printer->PrintRaw("\n");
174  }
175 
176  if (!file->package().empty()) {
177  std::vector<std::string> parts = file->package_parts();
178 
179  for (auto part = parts.begin(); part != parts.end(); part++) {
180  vars["part"] = *part;
181  printer->Print(vars, "namespace $part$ {\n");
182  }
183  printer->Print(vars, "\n");
184  }
185  }
186  return output;
187 }
188 
189 void PrintHeaderClientMethodInterfaces(grpc_generator::Printer* printer,
190  const grpc_generator::Method* method,
191  std::map<std::string, std::string>* vars,
192  bool is_public) {
193  (*vars)["Method"] = method->name();
194  (*vars)["Request"] = method->input_type_name();
195  (*vars)["Response"] = method->output_type_name();
196 
197  struct {
198  std::string prefix;
199  std::string method_params; // extra arguments to method
200  std::string raw_args; // extra arguments to raw version of method
201  } async_prefixes[] = {{"Async", ", void* tag", ", tag"},
202  {"PrepareAsync", "", ""}};
203 
204  if (is_public) {
205  if (method->NoStreaming()) {
206  printer->Print(
207  *vars,
208  "virtual ::grpc::Status $Method$(::grpc::ClientContext* context, "
209  "const $Request$& request, $Response$* response) = 0;\n");
210  for (auto async_prefix : async_prefixes) {
211  (*vars)["AsyncPrefix"] = async_prefix.prefix;
212  printer->Print(
213  *vars,
214  "std::unique_ptr< "
215  "::grpc::ClientAsyncResponseReaderInterface< $Response$>> "
216  "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
217  "const $Request$& request, "
218  "::grpc::CompletionQueue* cq) {\n");
219  printer->Indent();
220  printer->Print(
221  *vars,
222  "return std::unique_ptr< "
223  "::grpc::ClientAsyncResponseReaderInterface< $Response$>>("
224  "$AsyncPrefix$$Method$Raw(context, request, cq));\n");
225  printer->Outdent();
226  printer->Print("}\n");
227  }
228  } else if (ClientOnlyStreaming(method)) {
229  printer->Print(
230  *vars,
231  "std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>"
232  " $Method$("
233  "::grpc::ClientContext* context, $Response$* response) {\n");
234  printer->Indent();
235  printer->Print(
236  *vars,
237  "return std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>"
238  "($Method$Raw(context, response));\n");
239  printer->Outdent();
240  printer->Print("}\n");
241  for (auto async_prefix : async_prefixes) {
242  (*vars)["AsyncPrefix"] = async_prefix.prefix;
243  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
244  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
245  printer->Print(
246  *vars,
247  "std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>"
248  " $AsyncPrefix$$Method$(::grpc::ClientContext* context, "
249  "$Response$* "
250  "response, "
251  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
252  printer->Indent();
253  printer->Print(*vars,
254  "return std::unique_ptr< "
255  "::grpc::ClientAsyncWriterInterface< $Request$>>("
256  "$AsyncPrefix$$Method$Raw(context, response, "
257  "cq$AsyncRawArgs$));\n");
258  printer->Outdent();
259  printer->Print("}\n");
260  }
261  } else if (ServerOnlyStreaming(method)) {
262  printer->Print(
263  *vars,
264  "std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>"
265  " $Method$(::grpc::ClientContext* context, const $Request$& request)"
266  " {\n");
267  printer->Indent();
268  printer->Print(
269  *vars,
270  "return std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>"
271  "($Method$Raw(context, request));\n");
272  printer->Outdent();
273  printer->Print("}\n");
274  for (auto& async_prefix : async_prefixes) {
275  (*vars)["AsyncPrefix"] = async_prefix.prefix;
276  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
277  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
278  printer->Print(
279  *vars,
280  "std::unique_ptr< ::grpc::ClientAsyncReaderInterface< $Response$>> "
281  "$AsyncPrefix$$Method$("
282  "::grpc::ClientContext* context, const $Request$& request, "
283  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
284  printer->Indent();
285  printer->Print(
286  *vars,
287  "return std::unique_ptr< "
288  "::grpc::ClientAsyncReaderInterface< $Response$>>("
289  "$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\n");
290  printer->Outdent();
291  printer->Print("}\n");
292  }
293  } else if (method->BidiStreaming()) {
294  printer->Print(*vars,
295  "std::unique_ptr< ::grpc::ClientReaderWriterInterface< "
296  "$Request$, $Response$>> "
297  "$Method$(::grpc::ClientContext* context) {\n");
298  printer->Indent();
299  printer->Print(
300  *vars,
301  "return std::unique_ptr< "
302  "::grpc::ClientReaderWriterInterface< $Request$, $Response$>>("
303  "$Method$Raw(context));\n");
304  printer->Outdent();
305  printer->Print("}\n");
306  for (auto async_prefix : async_prefixes) {
307  (*vars)["AsyncPrefix"] = async_prefix.prefix;
308  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
309  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
310  printer->Print(
311  *vars,
312  "std::unique_ptr< "
313  "::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>> "
314  "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
315  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
316  printer->Indent();
317  printer->Print(
318  *vars,
319  "return std::unique_ptr< "
320  "::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>>("
321  "$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\n");
322  printer->Outdent();
323  printer->Print("}\n");
324  }
325  }
326  } else {
327  if (method->NoStreaming()) {
328  for (auto async_prefix : async_prefixes) {
329  (*vars)["AsyncPrefix"] = async_prefix.prefix;
330  printer->Print(
331  *vars,
332  "virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* "
333  "$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
334  "const $Request$& request, "
335  "::grpc::CompletionQueue* cq) = 0;\n");
336  }
337  } else if (ClientOnlyStreaming(method)) {
338  printer->Print(
339  *vars,
340  "virtual ::grpc::ClientWriterInterface< $Request$>*"
341  " $Method$Raw("
342  "::grpc::ClientContext* context, $Response$* response) = 0;\n");
343  for (auto async_prefix : async_prefixes) {
344  (*vars)["AsyncPrefix"] = async_prefix.prefix;
345  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
346  printer->Print(
347  *vars,
348  "virtual ::grpc::ClientAsyncWriterInterface< $Request$>*"
349  " $AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
350  "$Response$* response, "
351  "::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
352  }
353  } else if (ServerOnlyStreaming(method)) {
354  printer->Print(
355  *vars,
356  "virtual ::grpc::ClientReaderInterface< $Response$>* "
357  "$Method$Raw("
358  "::grpc::ClientContext* context, const $Request$& request) = 0;\n");
359  for (auto async_prefix : async_prefixes) {
360  (*vars)["AsyncPrefix"] = async_prefix.prefix;
361  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
362  printer->Print(
363  *vars,
364  "virtual ::grpc::ClientAsyncReaderInterface< $Response$>* "
365  "$AsyncPrefix$$Method$Raw("
366  "::grpc::ClientContext* context, const $Request$& request, "
367  "::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
368  }
369  } else if (method->BidiStreaming()) {
370  printer->Print(*vars,
371  "virtual ::grpc::ClientReaderWriterInterface< $Request$, "
372  "$Response$>* "
373  "$Method$Raw(::grpc::ClientContext* context) = 0;\n");
374  for (auto async_prefix : async_prefixes) {
375  (*vars)["AsyncPrefix"] = async_prefix.prefix;
376  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
377  printer->Print(
378  *vars,
379  "virtual ::grpc::ClientAsyncReaderWriterInterface< "
380  "$Request$, $Response$>* "
381  "$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
382  "::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
383  }
384  }
385  }
386 }
387 
388 void PrintHeaderClientMethod(grpc_generator::Printer* printer,
389  const grpc_generator::Method* method,
390  std::map<std::string, std::string>* vars,
391  bool is_public) {
392  (*vars)["Method"] = method->name();
393  (*vars)["Request"] = method->input_type_name();
394  (*vars)["Response"] = method->output_type_name();
395  struct {
396  std::string prefix;
397  std::string method_params; // extra arguments to method
398  std::string raw_args; // extra arguments to raw version of method
399  } async_prefixes[] = {{"Async", ", void* tag", ", tag"},
400  {"PrepareAsync", "", ""}};
401 
402  if (is_public) {
403  if (method->NoStreaming()) {
404  printer->Print(
405  *vars,
406  "::grpc::Status $Method$(::grpc::ClientContext* context, "
407  "const $Request$& request, $Response$* response) override;\n");
408  for (auto async_prefix : async_prefixes) {
409  (*vars)["AsyncPrefix"] = async_prefix.prefix;
410  printer->Print(
411  *vars,
412  "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
413  "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
414  "const $Request$& request, "
415  "::grpc::CompletionQueue* cq) {\n");
416  printer->Indent();
417  printer->Print(*vars,
418  "return std::unique_ptr< "
419  "::grpc::ClientAsyncResponseReader< $Response$>>("
420  "$AsyncPrefix$$Method$Raw(context, request, cq));\n");
421  printer->Outdent();
422  printer->Print("}\n");
423  }
424  } else if (ClientOnlyStreaming(method)) {
425  printer->Print(
426  *vars,
427  "std::unique_ptr< ::grpc::ClientWriter< $Request$>>"
428  " $Method$("
429  "::grpc::ClientContext* context, $Response$* response) {\n");
430  printer->Indent();
431  printer->Print(*vars,
432  "return std::unique_ptr< ::grpc::ClientWriter< $Request$>>"
433  "($Method$Raw(context, response));\n");
434  printer->Outdent();
435  printer->Print("}\n");
436  for (auto async_prefix : async_prefixes) {
437  (*vars)["AsyncPrefix"] = async_prefix.prefix;
438  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
439  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
440  printer->Print(*vars,
441  "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>"
442  " $AsyncPrefix$$Method$(::grpc::ClientContext* context, "
443  "$Response$* response, "
444  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
445  printer->Indent();
446  printer->Print(
447  *vars,
448  "return std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>("
449  "$AsyncPrefix$$Method$Raw(context, response, "
450  "cq$AsyncRawArgs$));\n");
451  printer->Outdent();
452  printer->Print("}\n");
453  }
454  } else if (ServerOnlyStreaming(method)) {
455  printer->Print(
456  *vars,
457  "std::unique_ptr< ::grpc::ClientReader< $Response$>>"
458  " $Method$(::grpc::ClientContext* context, const $Request$& request)"
459  " {\n");
460  printer->Indent();
461  printer->Print(
462  *vars,
463  "return std::unique_ptr< ::grpc::ClientReader< $Response$>>"
464  "($Method$Raw(context, request));\n");
465  printer->Outdent();
466  printer->Print("}\n");
467  for (auto async_prefix : async_prefixes) {
468  (*vars)["AsyncPrefix"] = async_prefix.prefix;
469  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
470  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
471  printer->Print(
472  *vars,
473  "std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> "
474  "$AsyncPrefix$$Method$("
475  "::grpc::ClientContext* context, const $Request$& request, "
476  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
477  printer->Indent();
478  printer->Print(
479  *vars,
480  "return std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>>("
481  "$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\n");
482  printer->Outdent();
483  printer->Print("}\n");
484  }
485  } else if (method->BidiStreaming()) {
486  printer->Print(
487  *vars,
488  "std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>>"
489  " $Method$(::grpc::ClientContext* context) {\n");
490  printer->Indent();
491  printer->Print(*vars,
492  "return std::unique_ptr< "
493  "::grpc::ClientReaderWriter< $Request$, $Response$>>("
494  "$Method$Raw(context));\n");
495  printer->Outdent();
496  printer->Print("}\n");
497  for (auto async_prefix : async_prefixes) {
498  (*vars)["AsyncPrefix"] = async_prefix.prefix;
499  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
500  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
501  printer->Print(*vars,
502  "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
503  "$Request$, $Response$>> "
504  "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
505  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
506  printer->Indent();
507  printer->Print(
508  *vars,
509  "return std::unique_ptr< "
510  "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>("
511  "$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\n");
512  printer->Outdent();
513  printer->Print("}\n");
514  }
515  }
516  } else {
517  if (method->NoStreaming()) {
518  for (auto async_prefix : async_prefixes) {
519  (*vars)["AsyncPrefix"] = async_prefix.prefix;
520  printer->Print(
521  *vars,
522  "::grpc::ClientAsyncResponseReader< $Response$>* "
523  "$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
524  "const $Request$& request, "
525  "::grpc::CompletionQueue* cq) override;\n");
526  }
527  } else if (ClientOnlyStreaming(method)) {
528  printer->Print(*vars,
529  "::grpc::ClientWriter< $Request$>* $Method$Raw("
530  "::grpc::ClientContext* context, $Response$* response) "
531  "override;\n");
532  for (auto async_prefix : async_prefixes) {
533  (*vars)["AsyncPrefix"] = async_prefix.prefix;
534  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
535  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
536  printer->Print(
537  *vars,
538  "::grpc::ClientAsyncWriter< $Request$>* $AsyncPrefix$$Method$Raw("
539  "::grpc::ClientContext* context, $Response$* response, "
540  "::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
541  }
542  } else if (ServerOnlyStreaming(method)) {
543  printer->Print(*vars,
544  "::grpc::ClientReader< $Response$>* $Method$Raw("
545  "::grpc::ClientContext* context, const $Request$& request)"
546  " override;\n");
547  for (auto async_prefix : async_prefixes) {
548  (*vars)["AsyncPrefix"] = async_prefix.prefix;
549  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
550  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
551  printer->Print(
552  *vars,
553  "::grpc::ClientAsyncReader< $Response$>* $AsyncPrefix$$Method$Raw("
554  "::grpc::ClientContext* context, const $Request$& request, "
555  "::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
556  }
557  } else if (method->BidiStreaming()) {
558  printer->Print(*vars,
559  "::grpc::ClientReaderWriter< $Request$, $Response$>* "
560  "$Method$Raw(::grpc::ClientContext* context) override;\n");
561  for (auto async_prefix : async_prefixes) {
562  (*vars)["AsyncPrefix"] = async_prefix.prefix;
563  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
564  (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
565  printer->Print(
566  *vars,
567  "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
568  "$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
569  "::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
570  }
571  }
572  }
573 }
574 
575 void PrintHeaderClientMethodCallbackInterfacesStart(
576  grpc_generator::Printer* printer,
577  std::map<std::string, std::string>* /*vars*/) {
578  // This declares the interface for the callback-based API. The components
579  // are pure; even though this is new (post-1.0) API, it can be pure because
580  // it is an entirely new interface that happens to be scoped within
581  // StubInterface, not new additions to StubInterface itself
582  printer->Print("class async_interface {\n");
583  // All methods in this new interface are public. There is no need for private
584  // "Raw" methods since the callback-based API returns unowned raw pointers
585  printer->Print(" public:\n");
586  printer->Indent();
587  printer->Print("virtual ~async_interface() {}\n");
588 }
589 
590 void PrintHeaderClientMethodCallbackInterfaces(
591  grpc_generator::Printer* printer, const grpc_generator::Method* method,
592  std::map<std::string, std::string>* vars) {
593  (*vars)["Method"] = method->name();
594  (*vars)["Request"] = method->input_type_name();
595  (*vars)["Response"] = method->output_type_name();
596 
597  if (method->NoStreaming()) {
598  printer->Print(*vars,
599  "virtual void $Method$(::grpc::ClientContext* context, "
600  "const $Request$* request, $Response$* response, "
601  "std::function<void(::grpc::Status)>) = 0;\n");
602  printer->Print(*vars,
603  "virtual void $Method$(::grpc::ClientContext* context, "
604  "const $Request$* request, $Response$* response, "
605  "::grpc::ClientUnaryReactor* reactor) = 0;\n");
606  } else if (ClientOnlyStreaming(method)) {
607  printer->Print(*vars,
608  "virtual void $Method$(::grpc::ClientContext* context, "
609  "$Response$* response, "
610  "::grpc::ClientWriteReactor< $Request$>* "
611  "reactor) = 0;\n");
612  } else if (ServerOnlyStreaming(method)) {
613  printer->Print(*vars,
614  "virtual void $Method$(::grpc::ClientContext* context, "
615  "const $Request$* request, "
616  "::grpc::ClientReadReactor< $Response$>* "
617  "reactor) = 0;\n");
618  } else if (method->BidiStreaming()) {
619  printer->Print(*vars,
620  "virtual void $Method$(::grpc::ClientContext* context, "
621  "::grpc::ClientBidiReactor< "
622  "$Request$,$Response$>* reactor) = 0;\n");
623  }
624 }
625 
626 void PrintHeaderClientMethodCallbackInterfacesEnd(
627  grpc_generator::Printer* printer,
628  std::map<std::string, std::string>* /*vars*/) {
629  printer->Outdent();
630  printer->Print("};\n");
631  // TODO: Remove typedef when all uses of experimental_async are migrated off.
632  printer->Print(
633  "typedef class async_interface experimental_async_interface;\n");
634 
635  // Declare a function to give the async stub contents. It can't be pure
636  // since this is a new API in StubInterface, but it is meaningless by default
637  // (since any stub that wants to use it must have its own implementation of
638  // the callback functions therein), so make the default return value nullptr.
639  // Intentionally include the word "class" to avoid possible shadowing.
640  // TODO: Remove experimental_async call when possible, replace with nullptr.
641  printer->Print(
642  "virtual class async_interface* async() { return nullptr; }\n");
643 
644  // TODO: Remove experimental_async call when possible.
645  printer->Print(
646  "class async_interface* experimental_async() { return async(); }\n");
647 }
648 
649 void PrintHeaderClientMethodCallbackStart(
650  grpc_generator::Printer* printer,
651  std::map<std::string, std::string>* /*vars*/) {
652  // This declares the stub entry for the callback-based API.
653  printer->Print("class async final :\n");
654  printer->Print(" public StubInterface::async_interface {\n");
655  printer->Print(" public:\n");
656  printer->Indent();
657 }
658 
659 void PrintHeaderClientMethodCallback(grpc_generator::Printer* printer,
660  const grpc_generator::Method* method,
661  std::map<std::string, std::string>* vars) {
662  (*vars)["Method"] = method->name();
663  (*vars)["Request"] = method->input_type_name();
664  (*vars)["Response"] = method->output_type_name();
665 
666  if (method->NoStreaming()) {
667  printer->Print(*vars,
668  "void $Method$(::grpc::ClientContext* context, "
669  "const $Request$* request, $Response$* response, "
670  "std::function<void(::grpc::Status)>) override;\n");
671  printer->Print(*vars,
672  "void $Method$(::grpc::ClientContext* context, "
673  "const $Request$* request, $Response$* response, "
674  "::grpc::ClientUnaryReactor* reactor) override;\n");
675  } else if (ClientOnlyStreaming(method)) {
676  printer->Print(*vars,
677  "void $Method$(::grpc::ClientContext* context, "
678  "$Response$* response, "
679  "::grpc::ClientWriteReactor< $Request$>* "
680  "reactor) override;\n");
681  } else if (ServerOnlyStreaming(method)) {
682  printer->Print(*vars,
683  "void $Method$(::grpc::ClientContext* context, "
684  "const $Request$* request, "
685  "::grpc::ClientReadReactor< $Response$>* "
686  "reactor) override;\n");
687 
688  } else if (method->BidiStreaming()) {
689  printer->Print(*vars,
690  "void $Method$(::grpc::ClientContext* context, "
691  "::grpc::ClientBidiReactor< "
692  "$Request$,$Response$>* reactor) override;\n");
693  }
694 }
695 
696 void PrintHeaderClientMethodCallbackEnd(
697  grpc_generator::Printer* printer,
698  std::map<std::string, std::string>* /*vars*/) {
699  printer->Outdent();
700  printer->Print(" private:\n");
701  printer->Indent();
702  printer->Print("friend class Stub;\n");
703  printer->Print("explicit async(Stub* stub): stub_(stub) { }\n");
704  // include a function with a phony use of stub_ to avoid an unused
705  // private member warning for service with no methods
706  printer->Print("Stub* stub() { return stub_; }\n");
707  printer->Print("Stub* stub_;\n");
708  printer->Outdent();
709  printer->Print("};\n");
710 
711  printer->Print(
712  "class async* async() override { "
713  "return &async_stub_; }\n");
714 }
715 
716 void PrintHeaderClientMethodData(grpc_generator::Printer* printer,
717  const grpc_generator::Method* method,
718  std::map<std::string, std::string>* vars) {
719  (*vars)["Method"] = method->name();
720  printer->Print(*vars,
721  "const ::grpc::internal::RpcMethod rpcmethod_$Method$_;\n");
722 }
723 
724 void PrintHeaderServerMethodSync(grpc_generator::Printer* printer,
725  const grpc_generator::Method* method,
726  std::map<std::string, std::string>* vars) {
727  (*vars)["Method"] = method->name();
728  (*vars)["Request"] = method->input_type_name();
729  (*vars)["Response"] = method->output_type_name();
730  printer->Print(method->GetLeadingComments("//").c_str());
731  if (method->NoStreaming()) {
732  printer->Print(*vars,
733  "virtual ::grpc::Status $Method$("
734  "::grpc::ServerContext* context, const $Request$* request, "
735  "$Response$* response);\n");
736  } else if (ClientOnlyStreaming(method)) {
737  printer->Print(*vars,
738  "virtual ::grpc::Status $Method$("
739  "::grpc::ServerContext* context, "
740  "::grpc::ServerReader< $Request$>* reader, "
741  "$Response$* response);\n");
742  } else if (ServerOnlyStreaming(method)) {
743  printer->Print(*vars,
744  "virtual ::grpc::Status $Method$("
745  "::grpc::ServerContext* context, const $Request$* request, "
746  "::grpc::ServerWriter< $Response$>* writer);\n");
747  } else if (method->BidiStreaming()) {
748  printer->Print(
749  *vars,
750  "virtual ::grpc::Status $Method$("
751  "::grpc::ServerContext* context, "
752  "::grpc::ServerReaderWriter< $Response$, $Request$>* stream);"
753  "\n");
754  }
755  printer->Print(method->GetTrailingComments("//").c_str());
756 }
757 
758 // Helper generator. Disables the sync API for Request and Response, then adds
759 // in an async API for RealRequest and RealResponse types. This is to be used
760 // to generate async and raw async APIs.
761 void PrintHeaderServerAsyncMethodsHelper(
762  grpc_generator::Printer* printer, const grpc_generator::Method* method,
763  std::map<std::string, std::string>* vars) {
764  if (method->NoStreaming()) {
765  printer->Print(
766  *vars,
767  "// disable synchronous version of this method\n"
768  "::grpc::Status $Method$("
769  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
770  "$Response$* /*response*/) override {\n"
771  " abort();\n"
772  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
773  "}\n");
774  printer->Print(
775  *vars,
776  "void Request$Method$("
777  "::grpc::ServerContext* context, $RealRequest$* request, "
778  "::grpc::ServerAsyncResponseWriter< $RealResponse$>* response, "
779  "::grpc::CompletionQueue* new_call_cq, "
780  "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
781  printer->Print(*vars,
782  " ::grpc::Service::RequestAsyncUnary($Idx$, context, "
783  "request, response, new_call_cq, notification_cq, tag);\n");
784  printer->Print("}\n");
785  } else if (ClientOnlyStreaming(method)) {
786  printer->Print(
787  *vars,
788  "// disable synchronous version of this method\n"
789  "::grpc::Status $Method$("
790  "::grpc::ServerContext* /*context*/, "
791  "::grpc::ServerReader< $Request$>* /*reader*/, "
792  "$Response$* /*response*/) override {\n"
793  " abort();\n"
794  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
795  "}\n");
796  printer->Print(
797  *vars,
798  "void Request$Method$("
799  "::grpc::ServerContext* context, "
800  "::grpc::ServerAsyncReader< $RealResponse$, $RealRequest$>* reader, "
801  "::grpc::CompletionQueue* new_call_cq, "
802  "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
803  printer->Print(*vars,
804  " ::grpc::Service::RequestAsyncClientStreaming($Idx$, "
805  "context, reader, new_call_cq, notification_cq, tag);\n");
806  printer->Print("}\n");
807  } else if (ServerOnlyStreaming(method)) {
808  printer->Print(
809  *vars,
810  "// disable synchronous version of this method\n"
811  "::grpc::Status $Method$("
812  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
813  "::grpc::ServerWriter< $Response$>* /*writer*/) override "
814  "{\n"
815  " abort();\n"
816  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
817  "}\n");
818  printer->Print(
819  *vars,
820  "void Request$Method$("
821  "::grpc::ServerContext* context, $RealRequest$* request, "
822  "::grpc::ServerAsyncWriter< $RealResponse$>* writer, "
823  "::grpc::CompletionQueue* new_call_cq, "
824  "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
825  printer->Print(
826  *vars,
827  " ::grpc::Service::RequestAsyncServerStreaming($Idx$, "
828  "context, request, writer, new_call_cq, notification_cq, tag);\n");
829  printer->Print("}\n");
830  } else if (method->BidiStreaming()) {
831  printer->Print(
832  *vars,
833  "// disable synchronous version of this method\n"
834  "::grpc::Status $Method$("
835  "::grpc::ServerContext* /*context*/, "
836  "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
837  " override {\n"
838  " abort();\n"
839  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
840  "}\n");
841  printer->Print(
842  *vars,
843  "void Request$Method$("
844  "::grpc::ServerContext* context, "
845  "::grpc::ServerAsyncReaderWriter< $RealResponse$, $RealRequest$>* "
846  "stream, "
847  "::grpc::CompletionQueue* new_call_cq, "
848  "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
849  printer->Print(*vars,
850  " ::grpc::Service::RequestAsyncBidiStreaming($Idx$, "
851  "context, stream, new_call_cq, notification_cq, tag);\n");
852  printer->Print("}\n");
853  }
854 }
855 
856 void PrintHeaderServerMethodAsync(grpc_generator::Printer* printer,
857  const grpc_generator::Method* method,
858  std::map<std::string, std::string>* vars) {
859  (*vars)["Method"] = method->name();
860  // These will be disabled
861  (*vars)["Request"] = method->input_type_name();
862  (*vars)["Response"] = method->output_type_name();
863  // These will be used for the async API
864  (*vars)["RealRequest"] = method->input_type_name();
865  (*vars)["RealResponse"] = method->output_type_name();
866  printer->Print(*vars, "template <class BaseClass>\n");
867  printer->Print(*vars,
868  "class WithAsyncMethod_$Method$ : public BaseClass {\n");
869  printer->Print(
870  " private:\n"
871  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
872  "{}\n");
873  printer->Print(" public:\n");
874  printer->Indent();
875  printer->Print(*vars,
876  "WithAsyncMethod_$Method$() {\n"
877  " ::grpc::Service::MarkMethodAsync($Idx$);\n"
878  "}\n");
879  printer->Print(*vars,
880  "~WithAsyncMethod_$Method$() override {\n"
881  " BaseClassMustBeDerivedFromService(this);\n"
882  "}\n");
883  PrintHeaderServerAsyncMethodsHelper(printer, method, vars);
884  printer->Outdent();
885  printer->Print(*vars, "};\n");
886 }
887 
888 // Helper generator. Disables the sync API for Request and Response, then adds
889 // in a callback API for RealRequest and RealResponse types. This is to be used
890 // to generate callback and raw callback APIs.
891 void PrintHeaderServerCallbackMethodsHelper(
892  grpc_generator::Printer* printer, const grpc_generator::Method* method,
893  std::map<std::string, std::string>* vars) {
894  if (method->NoStreaming()) {
895  printer->Print(
896  *vars,
897  "// disable synchronous version of this method\n"
898  "::grpc::Status $Method$("
899  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
900  "$Response$* /*response*/) override {\n"
901  " abort();\n"
902  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
903  "}\n");
904  printer->Print(*vars,
905  "virtual ::grpc::ServerUnaryReactor* $Method$(\n"
906  " ::grpc::CallbackServerContext* /*context*/, "
907  "const $RealRequest$* /*request*/, "
908  "$RealResponse$* /*response*/)"
909  " { return nullptr; }\n");
910  } else if (ClientOnlyStreaming(method)) {
911  printer->Print(
912  *vars,
913  "// disable synchronous version of this method\n"
914  "::grpc::Status $Method$("
915  "::grpc::ServerContext* /*context*/, "
916  "::grpc::ServerReader< $Request$>* /*reader*/, "
917  "$Response$* /*response*/) override {\n"
918  " abort();\n"
919  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
920  "}\n");
921  printer->Print(*vars,
922  "virtual ::grpc::ServerReadReactor< "
923  "$RealRequest$>* $Method$(\n"
924  " ::grpc::CallbackServerContext* "
925  "/*context*/, $RealResponse$* /*response*/)"
926  " { return nullptr; }\n");
927  } else if (ServerOnlyStreaming(method)) {
928  printer->Print(
929  *vars,
930  "// disable synchronous version of this method\n"
931  "::grpc::Status $Method$("
932  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
933  "::grpc::ServerWriter< $Response$>* /*writer*/) override "
934  "{\n"
935  " abort();\n"
936  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
937  "}\n");
938  printer->Print(
939  *vars,
940  "virtual ::grpc::ServerWriteReactor< $RealResponse$>* $Method$(\n"
941  " ::grpc::CallbackServerContext* "
942  "/*context*/, const $RealRequest$* /*request*/)"
943  " { return nullptr; }\n");
944  } else if (method->BidiStreaming()) {
945  printer->Print(
946  *vars,
947  "// disable synchronous version of this method\n"
948  "::grpc::Status $Method$("
949  "::grpc::ServerContext* /*context*/, "
950  "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
951  " override {\n"
952  " abort();\n"
953  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
954  "}\n");
955  printer->Print(
956  *vars,
957  "virtual ::grpc::ServerBidiReactor< $RealRequest$, $RealResponse$>* "
958  "$Method$(\n"
959  " ::grpc::CallbackServerContext* /*context*/)\n"
960  " { return nullptr; }\n");
961  }
962 }
963 
964 void PrintHeaderServerMethodCallback(grpc_generator::Printer* printer,
965  const grpc_generator::Method* method,
966  std::map<std::string, std::string>* vars) {
967  (*vars)["Method"] = method->name();
968  // These will be disabled
969  (*vars)["Request"] = method->input_type_name();
970  (*vars)["Response"] = method->output_type_name();
971  // These will be used for the callback API
972  (*vars)["RealRequest"] = method->input_type_name();
973  (*vars)["RealResponse"] = method->output_type_name();
974  printer->Print(*vars, "template <class BaseClass>\n");
975  printer->Print(*vars,
976  "class WithCallbackMethod_$Method$ : public BaseClass {\n");
977  printer->Print(
978  " private:\n"
979  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
980  "{}\n");
981  printer->Print(" public:\n");
982  printer->Indent();
983  printer->Print(*vars, "WithCallbackMethod_$Method$() {\n");
984  if (method->NoStreaming()) {
985  printer->Print(
986  *vars,
987  " ::grpc::Service::MarkMethodCallback($Idx$,\n"
988  " new ::grpc::internal::CallbackUnaryHandler< "
989  "$RealRequest$, $RealResponse$>(\n"
990  " [this](\n"
991  " ::grpc::CallbackServerContext* context, "
992  "const $RealRequest$* "
993  "request, "
994  "$RealResponse$* response) { "
995  "return this->$Method$(context, request, response); }));}\n");
996  printer->Print(*vars,
997  "void SetMessageAllocatorFor_$Method$(\n"
998  " ::grpc::MessageAllocator< "
999  "$RealRequest$, $RealResponse$>* allocator) {\n"
1000  " ::grpc::internal::MethodHandler* const handler = "
1001  "::grpc::Service::GetHandler($Idx$);\n"
1002  " static_cast<::grpc::internal::CallbackUnaryHandler< "
1003  "$RealRequest$, $RealResponse$>*>(handler)\n"
1004  " ->SetMessageAllocator(allocator);\n");
1005  } else if (ClientOnlyStreaming(method)) {
1006  printer->Print(
1007  *vars,
1008  " ::grpc::Service::MarkMethodCallback($Idx$,\n"
1009  " new ::grpc::internal::CallbackClientStreamingHandler< "
1010  "$RealRequest$, $RealResponse$>(\n"
1011  " [this](\n"
1012  " ::grpc::CallbackServerContext* context, "
1013  "$RealResponse$* "
1014  "response) { "
1015  "return this->$Method$(context, response); }));\n");
1016  } else if (ServerOnlyStreaming(method)) {
1017  printer->Print(
1018  *vars,
1019  " ::grpc::Service::MarkMethodCallback($Idx$,\n"
1020  " new ::grpc::internal::CallbackServerStreamingHandler< "
1021  "$RealRequest$, $RealResponse$>(\n"
1022  " [this](\n"
1023  " ::grpc::CallbackServerContext* context, "
1024  "const $RealRequest$* "
1025  "request) { "
1026  "return this->$Method$(context, request); }));\n");
1027  } else if (method->BidiStreaming()) {
1028  printer->Print(*vars,
1029  " ::grpc::Service::MarkMethodCallback($Idx$,\n"
1030  " new ::grpc::internal::CallbackBidiHandler< "
1031  "$RealRequest$, $RealResponse$>(\n"
1032  " [this](\n"
1033  " ::grpc::CallbackServerContext* context) "
1034  "{ return this->$Method$(context); }));\n");
1035  }
1036  printer->Print(*vars, "}\n");
1037  printer->Print(*vars,
1038  "~WithCallbackMethod_$Method$() override {\n"
1039  " BaseClassMustBeDerivedFromService(this);\n"
1040  "}\n");
1041  PrintHeaderServerCallbackMethodsHelper(printer, method, vars);
1042  printer->Outdent();
1043  printer->Print(*vars, "};\n");
1044 }
1045 
1046 void PrintHeaderServerMethodRawCallback(
1047  grpc_generator::Printer* printer, const grpc_generator::Method* method,
1048  std::map<std::string, std::string>* vars) {
1049  (*vars)["Method"] = method->name();
1050  // These will be disabled
1051  (*vars)["Request"] = method->input_type_name();
1052  (*vars)["Response"] = method->output_type_name();
1053  // These will be used for raw API
1054  (*vars)["RealRequest"] = "::grpc::ByteBuffer";
1055  (*vars)["RealResponse"] = "::grpc::ByteBuffer";
1056  printer->Print(*vars, "template <class BaseClass>\n");
1057  printer->Print(*vars,
1058  "class WithRawCallbackMethod_$Method$ : public "
1059  "BaseClass {\n");
1060  printer->Print(
1061  " private:\n"
1062  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
1063  "{}\n");
1064  printer->Print(" public:\n");
1065  printer->Indent();
1066  printer->Print(*vars, "WithRawCallbackMethod_$Method$() {\n");
1067  if (method->NoStreaming()) {
1068  printer->Print(*vars,
1069  " ::grpc::Service::MarkMethodRawCallback($Idx$,\n"
1070  " new ::grpc::internal::CallbackUnaryHandler< "
1071  "$RealRequest$, $RealResponse$>(\n"
1072  " [this](\n"
1073  " ::grpc::CallbackServerContext* context, "
1074  "const $RealRequest$* "
1075  "request, "
1076  "$RealResponse$* response) { return "
1077  "this->$Method$(context, request, response); }));\n");
1078  } else if (ClientOnlyStreaming(method)) {
1079  printer->Print(
1080  *vars,
1081  " ::grpc::Service::MarkMethodRawCallback($Idx$,\n"
1082  " new ::grpc::internal::CallbackClientStreamingHandler< "
1083  "$RealRequest$, $RealResponse$>(\n"
1084  " [this](\n"
1085  " ::grpc::CallbackServerContext* context, "
1086  "$RealResponse$* response) "
1087  "{ return this->$Method$(context, response); }));\n");
1088  } else if (ServerOnlyStreaming(method)) {
1089  printer->Print(
1090  *vars,
1091  " ::grpc::Service::MarkMethodRawCallback($Idx$,\n"
1092  " new ::grpc::internal::CallbackServerStreamingHandler< "
1093  "$RealRequest$, $RealResponse$>(\n"
1094  " [this](\n"
1095  " ::grpc::CallbackServerContext* context, "
1096  "const"
1097  "$RealRequest$* request) { return "
1098  "this->$Method$(context, request); }));\n");
1099  } else if (method->BidiStreaming()) {
1100  printer->Print(*vars,
1101  " ::grpc::Service::MarkMethodRawCallback($Idx$,\n"
1102  " new ::grpc::internal::CallbackBidiHandler< "
1103  "$RealRequest$, $RealResponse$>(\n"
1104  " [this](\n"
1105  " ::grpc::CallbackServerContext* context) "
1106  "{ return this->$Method$(context); }));\n");
1107  }
1108  printer->Print(*vars, "}\n");
1109  printer->Print(*vars,
1110  "~WithRawCallbackMethod_$Method$() override {\n"
1111  " BaseClassMustBeDerivedFromService(this);\n"
1112  "}\n");
1113  PrintHeaderServerCallbackMethodsHelper(printer, method, vars);
1114  printer->Outdent();
1115  printer->Print(*vars, "};\n");
1116 }
1117 
1118 void PrintHeaderServerMethodStreamedUnary(
1119  grpc_generator::Printer* printer, const grpc_generator::Method* method,
1120  std::map<std::string, std::string>* vars) {
1121  (*vars)["Method"] = method->name();
1122  (*vars)["Request"] = method->input_type_name();
1123  (*vars)["Response"] = method->output_type_name();
1124  if (method->NoStreaming()) {
1125  printer->Print(*vars, "template <class BaseClass>\n");
1126  printer->Print(*vars,
1127  "class WithStreamedUnaryMethod_$Method$ : "
1128  "public BaseClass {\n");
1129  printer->Print(
1130  " private:\n"
1131  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
1132  "{}\n");
1133  printer->Print(" public:\n");
1134  printer->Indent();
1135  printer->Print(*vars,
1136  "WithStreamedUnaryMethod_$Method$() {\n"
1137  " ::grpc::Service::MarkMethodStreamed($Idx$,\n"
1138  " new ::grpc::internal::StreamedUnaryHandler<\n"
1139  " $Request$, $Response$>(\n"
1140  " [this](::grpc::ServerContext* context,\n"
1141  " ::grpc::ServerUnaryStreamer<\n"
1142  " $Request$, $Response$>* streamer) {\n"
1143  " return this->Streamed$Method$(context,\n"
1144  " streamer);\n"
1145  " }));\n"
1146  "}\n");
1147  printer->Print(*vars,
1148  "~WithStreamedUnaryMethod_$Method$() override {\n"
1149  " BaseClassMustBeDerivedFromService(this);\n"
1150  "}\n");
1151  printer->Print(
1152  *vars,
1153  "// disable regular version of this method\n"
1154  "::grpc::Status $Method$("
1155  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
1156  "$Response$* /*response*/) override {\n"
1157  " abort();\n"
1158  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1159  "}\n");
1160  printer->Print(*vars,
1161  "// replace default version of method with streamed unary\n"
1162  "virtual ::grpc::Status Streamed$Method$("
1163  "::grpc::ServerContext* context, "
1164  "::grpc::ServerUnaryStreamer< "
1165  "$Request$,$Response$>* server_unary_streamer)"
1166  " = 0;\n");
1167  printer->Outdent();
1168  printer->Print(*vars, "};\n");
1169  }
1170 }
1171 
1172 void PrintHeaderServerMethodSplitStreaming(
1173  grpc_generator::Printer* printer, const grpc_generator::Method* method,
1174  std::map<std::string, std::string>* vars) {
1175  (*vars)["Method"] = method->name();
1176  (*vars)["Request"] = method->input_type_name();
1177  (*vars)["Response"] = method->output_type_name();
1178  if (ServerOnlyStreaming(method)) {
1179  printer->Print(*vars, "template <class BaseClass>\n");
1180  printer->Print(*vars,
1181  "class WithSplitStreamingMethod_$Method$ : "
1182  "public BaseClass {\n");
1183  printer->Print(
1184  " private:\n"
1185  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
1186  "{}\n");
1187  printer->Print(" public:\n");
1188  printer->Indent();
1189  printer->Print(*vars,
1190  "WithSplitStreamingMethod_$Method$() {\n"
1191  " ::grpc::Service::MarkMethodStreamed($Idx$,\n"
1192  " new ::grpc::internal::SplitServerStreamingHandler<\n"
1193  " $Request$, $Response$>(\n"
1194  " [this](::grpc::ServerContext* context,\n"
1195  " ::grpc::ServerSplitStreamer<\n"
1196  " $Request$, $Response$>* streamer) {\n"
1197  " return this->Streamed$Method$(context,\n"
1198  " streamer);\n"
1199  " }));\n"
1200  "}\n");
1201  printer->Print(*vars,
1202  "~WithSplitStreamingMethod_$Method$() override {\n"
1203  " BaseClassMustBeDerivedFromService(this);\n"
1204  "}\n");
1205  printer->Print(
1206  *vars,
1207  "// disable regular version of this method\n"
1208  "::grpc::Status $Method$("
1209  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
1210  "::grpc::ServerWriter< $Response$>* /*writer*/) override "
1211  "{\n"
1212  " abort();\n"
1213  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1214  "}\n");
1215  printer->Print(*vars,
1216  "// replace default version of method with split streamed\n"
1217  "virtual ::grpc::Status Streamed$Method$("
1218  "::grpc::ServerContext* context, "
1219  "::grpc::ServerSplitStreamer< "
1220  "$Request$,$Response$>* server_split_streamer)"
1221  " = 0;\n");
1222  printer->Outdent();
1223  printer->Print(*vars, "};\n");
1224  }
1225 }
1226 
1227 void PrintHeaderServerMethodGeneric(grpc_generator::Printer* printer,
1228  const grpc_generator::Method* method,
1229  std::map<std::string, std::string>* vars) {
1230  (*vars)["Method"] = method->name();
1231  (*vars)["Request"] = method->input_type_name();
1232  (*vars)["Response"] = method->output_type_name();
1233  printer->Print(*vars, "template <class BaseClass>\n");
1234  printer->Print(*vars,
1235  "class WithGenericMethod_$Method$ : public BaseClass {\n");
1236  printer->Print(
1237  " private:\n"
1238  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
1239  "{}\n");
1240  printer->Print(" public:\n");
1241  printer->Indent();
1242  printer->Print(*vars,
1243  "WithGenericMethod_$Method$() {\n"
1244  " ::grpc::Service::MarkMethodGeneric($Idx$);\n"
1245  "}\n");
1246  printer->Print(*vars,
1247  "~WithGenericMethod_$Method$() override {\n"
1248  " BaseClassMustBeDerivedFromService(this);\n"
1249  "}\n");
1250  if (method->NoStreaming()) {
1251  printer->Print(
1252  *vars,
1253  "// disable synchronous version of this method\n"
1254  "::grpc::Status $Method$("
1255  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
1256  "$Response$* /*response*/) override {\n"
1257  " abort();\n"
1258  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1259  "}\n");
1260  } else if (ClientOnlyStreaming(method)) {
1261  printer->Print(
1262  *vars,
1263  "// disable synchronous version of this method\n"
1264  "::grpc::Status $Method$("
1265  "::grpc::ServerContext* /*context*/, "
1266  "::grpc::ServerReader< $Request$>* /*reader*/, "
1267  "$Response$* /*response*/) override {\n"
1268  " abort();\n"
1269  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1270  "}\n");
1271  } else if (ServerOnlyStreaming(method)) {
1272  printer->Print(
1273  *vars,
1274  "// disable synchronous version of this method\n"
1275  "::grpc::Status $Method$("
1276  "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
1277  "::grpc::ServerWriter< $Response$>* /*writer*/) override "
1278  "{\n"
1279  " abort();\n"
1280  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1281  "}\n");
1282  } else if (method->BidiStreaming()) {
1283  printer->Print(
1284  *vars,
1285  "// disable synchronous version of this method\n"
1286  "::grpc::Status $Method$("
1287  "::grpc::ServerContext* /*context*/, "
1288  "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
1289  " override {\n"
1290  " abort();\n"
1291  " return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
1292  "}\n");
1293  }
1294  printer->Outdent();
1295  printer->Print(*vars, "};\n");
1296 }
1297 
1298 void PrintHeaderServerMethodRaw(grpc_generator::Printer* printer,
1299  const grpc_generator::Method* method,
1300  std::map<std::string, std::string>* vars) {
1301  (*vars)["Method"] = method->name();
1302  // These will be disabled
1303  (*vars)["Request"] = method->input_type_name();
1304  (*vars)["Response"] = method->output_type_name();
1305  // These will be used for raw API
1306  (*vars)["RealRequest"] = "::grpc::ByteBuffer";
1307  (*vars)["RealResponse"] = "::grpc::ByteBuffer";
1308  printer->Print(*vars, "template <class BaseClass>\n");
1309  printer->Print(*vars, "class WithRawMethod_$Method$ : public BaseClass {\n");
1310  printer->Print(
1311  " private:\n"
1312  " void BaseClassMustBeDerivedFromService(const Service* /*service*/) "
1313  "{}\n");
1314  printer->Print(" public:\n");
1315  printer->Indent();
1316  printer->Print(*vars,
1317  "WithRawMethod_$Method$() {\n"
1318  " ::grpc::Service::MarkMethodRaw($Idx$);\n"
1319  "}\n");
1320  printer->Print(*vars,
1321  "~WithRawMethod_$Method$() override {\n"
1322  " BaseClassMustBeDerivedFromService(this);\n"
1323  "}\n");
1324  PrintHeaderServerAsyncMethodsHelper(printer, method, vars);
1325  printer->Outdent();
1326  printer->Print(*vars, "};\n");
1327 }
1328 
1329 void PrintHeaderService(grpc_generator::Printer* printer,
1330  const grpc_generator::Service* service,
1331  std::map<std::string, std::string>* vars) {
1332  (*vars)["Service"] = service->name();
1333 
1334  printer->Print(service->GetLeadingComments("//").c_str());
1335  printer->Print(*vars,
1336  "class $Service$ final {\n"
1337  " public:\n");
1338  printer->Indent();
1339 
1340  // Service metadata
1341  printer->Print(*vars,
1342  "static constexpr char const* service_full_name() {\n"
1343  " return \"$Package$$Service$\";\n"
1344  "}\n");
1345 
1346  // Client side
1347  printer->Print(
1348  "class StubInterface {\n"
1349  " public:\n");
1350  printer->Indent();
1351  printer->Print("virtual ~StubInterface() {}\n");
1352  for (int i = 0; i < service->method_count(); ++i) {
1353  printer->Print(service->method(i)->GetLeadingComments("//").c_str());
1354  PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,
1355  true);
1356  printer->Print(service->method(i)->GetTrailingComments("//").c_str());
1357  }
1358  PrintHeaderClientMethodCallbackInterfacesStart(printer, vars);
1359  for (int i = 0; i < service->method_count(); ++i) {
1360  printer->Print(service->method(i)->GetLeadingComments("//").c_str());
1361  PrintHeaderClientMethodCallbackInterfaces(printer, service->method(i).get(),
1362  vars);
1363  printer->Print(service->method(i)->GetTrailingComments("//").c_str());
1364  }
1365  PrintHeaderClientMethodCallbackInterfacesEnd(printer, vars);
1366  printer->Outdent();
1367  printer->Print(" private:\n");
1368  printer->Indent();
1369  for (int i = 0; i < service->method_count(); ++i) {
1370  PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,
1371  false);
1372  }
1373  printer->Outdent();
1374  printer->Print("};\n");
1375  printer->Print(
1376  "class Stub final : public StubInterface"
1377  " {\n public:\n");
1378  printer->Indent();
1379  printer->Print(
1380  "Stub(const std::shared_ptr< ::grpc::ChannelInterface>& "
1381  "channel, const ::grpc::StubOptions& options = "
1382  "::grpc::StubOptions());\n");
1383  for (int i = 0; i < service->method_count(); ++i) {
1384  PrintHeaderClientMethod(printer, service->method(i).get(), vars, true);
1385  }
1386  PrintHeaderClientMethodCallbackStart(printer, vars);
1387  for (int i = 0; i < service->method_count(); ++i) {
1388  PrintHeaderClientMethodCallback(printer, service->method(i).get(), vars);
1389  }
1390  PrintHeaderClientMethodCallbackEnd(printer, vars);
1391  printer->Outdent();
1392  printer->Print("\n private:\n");
1393  printer->Indent();
1394  printer->Print("std::shared_ptr< ::grpc::ChannelInterface> channel_;\n");
1395  printer->Print("class async async_stub_{this};\n");
1396  for (int i = 0; i < service->method_count(); ++i) {
1397  PrintHeaderClientMethod(printer, service->method(i).get(), vars, false);
1398  }
1399  for (int i = 0; i < service->method_count(); ++i) {
1400  PrintHeaderClientMethodData(printer, service->method(i).get(), vars);
1401  }
1402  printer->Outdent();
1403  printer->Print("};\n");
1404  printer->Print(
1405  "static std::unique_ptr<Stub> NewStub(const std::shared_ptr< "
1406  "::grpc::ChannelInterface>& channel, "
1407  "const ::grpc::StubOptions& options = ::grpc::StubOptions());\n");
1408 
1409  printer->Print("\n");
1410 
1411  // Server side - base
1412  printer->Print(
1413  "class Service : public ::grpc::Service {\n"
1414  " public:\n");
1415  printer->Indent();
1416  printer->Print("Service();\n");
1417  printer->Print("virtual ~Service();\n");
1418  for (int i = 0; i < service->method_count(); ++i) {
1419  PrintHeaderServerMethodSync(printer, service->method(i).get(), vars);
1420  }
1421  printer->Outdent();
1422  printer->Print("};\n");
1423 
1424  // Server side - Asynchronous
1425  for (int i = 0; i < service->method_count(); ++i) {
1426  (*vars)["Idx"] = as_string(i);
1427  PrintHeaderServerMethodAsync(printer, service->method(i).get(), vars);
1428  }
1429 
1430  printer->Print("typedef ");
1431 
1432  for (int i = 0; i < service->method_count(); ++i) {
1433  (*vars)["method_name"] = service->method(i)->name();
1434  printer->Print(*vars, "WithAsyncMethod_$method_name$<");
1435  }
1436  printer->Print("Service");
1437  for (int i = 0; i < service->method_count(); ++i) {
1438  printer->Print(" >");
1439  }
1440  printer->Print(" AsyncService;\n");
1441 
1442  // Server side - Callback
1443  for (int i = 0; i < service->method_count(); ++i) {
1444  (*vars)["Idx"] = as_string(i);
1445  PrintHeaderServerMethodCallback(printer, service->method(i).get(), vars);
1446  }
1447 
1448  printer->Print("typedef ");
1449 
1450  for (int i = 0; i < service->method_count(); ++i) {
1451  (*vars)["method_name"] = service->method(i)->name();
1452  printer->Print(*vars, "WithCallbackMethod_$method_name$<");
1453  }
1454  printer->Print("Service");
1455  for (int i = 0; i < service->method_count(); ++i) {
1456  printer->Print(" >");
1457  }
1458  printer->Print(" CallbackService;\n");
1459 
1460  // TODO: Remove following typedef once all uses of ExperimentalCallbackService
1461  // are migrated to CallbackService
1462  printer->Print("typedef CallbackService ExperimentalCallbackService;\n");
1463 
1464  // Server side - Generic
1465  for (int i = 0; i < service->method_count(); ++i) {
1466  (*vars)["Idx"] = as_string(i);
1467  PrintHeaderServerMethodGeneric(printer, service->method(i).get(), vars);
1468  }
1469 
1470  // Server side - Raw
1471  for (int i = 0; i < service->method_count(); ++i) {
1472  (*vars)["Idx"] = as_string(i);
1473  PrintHeaderServerMethodRaw(printer, service->method(i).get(), vars);
1474  }
1475 
1476  // Server side - Raw Callback
1477  for (int i = 0; i < service->method_count(); ++i) {
1478  (*vars)["Idx"] = as_string(i);
1479  PrintHeaderServerMethodRawCallback(printer, service->method(i).get(), vars);
1480  }
1481 
1482  // Server side - Streamed Unary
1483  for (int i = 0; i < service->method_count(); ++i) {
1484  (*vars)["Idx"] = as_string(i);
1485  PrintHeaderServerMethodStreamedUnary(printer, service->method(i).get(),
1486  vars);
1487  }
1488 
1489  printer->Print("typedef ");
1490  for (int i = 0; i < service->method_count(); ++i) {
1491  (*vars)["method_name"] = service->method(i)->name();
1492  if (service->method(i)->NoStreaming()) {
1493  printer->Print(*vars, "WithStreamedUnaryMethod_$method_name$<");
1494  }
1495  }
1496  printer->Print("Service");
1497  for (int i = 0; i < service->method_count(); ++i) {
1498  if (service->method(i)->NoStreaming()) {
1499  printer->Print(" >");
1500  }
1501  }
1502  printer->Print(" StreamedUnaryService;\n");
1503 
1504  // Server side - controlled server-side streaming
1505  for (int i = 0; i < service->method_count(); ++i) {
1506  (*vars)["Idx"] = as_string(i);
1507  PrintHeaderServerMethodSplitStreaming(printer, service->method(i).get(),
1508  vars);
1509  }
1510 
1511  printer->Print("typedef ");
1512  for (int i = 0; i < service->method_count(); ++i) {
1513  (*vars)["method_name"] = service->method(i)->name();
1514  auto method = service->method(i);
1515  if (ServerOnlyStreaming(method.get())) {
1516  printer->Print(*vars, "WithSplitStreamingMethod_$method_name$<");
1517  }
1518  }
1519  printer->Print("Service");
1520  for (int i = 0; i < service->method_count(); ++i) {
1521  auto method = service->method(i);
1522  if (ServerOnlyStreaming(method.get())) {
1523  printer->Print(" >");
1524  }
1525  }
1526  printer->Print(" SplitStreamedService;\n");
1527 
1528  // Server side - typedef for controlled both unary and server-side streaming
1529  printer->Print("typedef ");
1530  for (int i = 0; i < service->method_count(); ++i) {
1531  (*vars)["method_name"] = service->method(i)->name();
1532  auto method = service->method(i);
1533  if (ServerOnlyStreaming(method.get())) {
1534  printer->Print(*vars, "WithSplitStreamingMethod_$method_name$<");
1535  }
1536  if (service->method(i)->NoStreaming()) {
1537  printer->Print(*vars, "WithStreamedUnaryMethod_$method_name$<");
1538  }
1539  }
1540  printer->Print("Service");
1541  for (int i = 0; i < service->method_count(); ++i) {
1542  auto method = service->method(i);
1543  if (service->method(i)->NoStreaming() ||
1544  ServerOnlyStreaming(method.get())) {
1545  printer->Print(" >");
1546  }
1547  }
1548  printer->Print(" StreamedService;\n");
1549 
1550  printer->Outdent();
1551  printer->Print("};\n");
1552  printer->Print(service->GetTrailingComments("//").c_str());
1553 }
1554 
1555 std::string GetHeaderServices(grpc_generator::File* file,
1556  const Parameters& params) {
1557  std::string output;
1558  {
1559  // Scope the output stream so it closes and finalizes output to the string.
1560  auto printer = file->CreatePrinter(&output);
1561  std::map<std::string, std::string> vars;
1562  // Package string is empty or ends with a dot. It is used to fully qualify
1563  // method names.
1564  vars["Package"] = file->package();
1565  if (!file->package().empty()) {
1566  vars["Package"].append(".");
1567  }
1568 
1569  if (!params.services_namespace.empty()) {
1570  vars["services_namespace"] = params.services_namespace;
1571  printer->Print(vars, "\nnamespace $services_namespace$ {\n\n");
1572  }
1573 
1574  for (int i = 0; i < file->service_count(); ++i) {
1575  PrintHeaderService(printer.get(), file->service(i).get(), &vars);
1576  printer->Print("\n");
1577  }
1578 
1579  if (!params.services_namespace.empty()) {
1580  printer->Print(vars, "} // namespace $services_namespace$\n\n");
1581  }
1582  }
1583  return output;
1584 }
1585 
1586 std::string GetHeaderEpilogue(grpc_generator::File* file,
1587  const Parameters& /*params*/) {
1588  std::string output;
1589  {
1590  // Scope the output stream so it closes and finalizes output to the string.
1591  auto printer = file->CreatePrinter(&output);
1592  std::map<std::string, std::string> vars;
1593 
1594  vars["filename"] = file->filename();
1595  vars["filename_identifier"] = FilenameIdentifier(file->filename());
1596 
1597  if (!file->package().empty()) {
1598  std::vector<std::string> parts = file->package_parts();
1599 
1600  for (auto part = parts.rbegin(); part != parts.rend(); part++) {
1601  vars["part"] = *part;
1602  printer->Print(vars, "} // namespace $part$\n");
1603  }
1604  printer->Print(vars, "\n");
1605  }
1606 
1607  printer->Print(vars, "\n");
1608  printer->Print(vars, "#endif // GRPC_$filename_identifier$__INCLUDED\n");
1609 
1610  printer->Print(file->GetTrailingComments("//").c_str());
1611  }
1612  return output;
1613 }
1614 
1615 std::string GetSourcePrologue(grpc_generator::File* file,
1616  const Parameters& params) {
1617  std::string output;
1618  {
1619  // Scope the output stream so it closes and finalizes output to the string.
1620  auto printer = file->CreatePrinter(&output);
1621  std::map<std::string, std::string> vars;
1622 
1623  vars["filename"] = file->filename();
1624  vars["filename_base"] = file->filename_without_ext();
1625  vars["message_header_ext"] = params.message_header_extension.empty()
1626  ? kCppGeneratorMessageHeaderExt
1627  : params.message_header_extension;
1628  vars["service_header_ext"] = kCppGeneratorServiceHeaderExt;
1629 
1630  printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
1631  printer->Print(vars,
1632  "// If you make any local change, they will be lost.\n");
1633  printer->Print(vars, "// source: $filename$\n\n");
1634 
1635  printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
1636  printer->Print(vars, "#include \"$filename_base$$service_header_ext$\"\n");
1637  printer->Print(vars, "\n");
1638  }
1639  return output;
1640 }
1641 
1642 std::string GetSourceIncludes(grpc_generator::File* file,
1643  const Parameters& params) {
1644  std::string output;
1645  {
1646  // Scope the output stream so it closes and finalizes output to the string.
1647  auto printer = file->CreatePrinter(&output);
1648  std::map<std::string, std::string> vars;
1649  static const char* headers_strs[] = {
1650  "functional",
1651  "grpcpp/impl/codegen/async_stream.h",
1652  "grpcpp/impl/codegen/async_unary_call.h",
1653  "grpcpp/impl/codegen/channel_interface.h",
1654  "grpcpp/impl/codegen/client_unary_call.h",
1655  "grpcpp/impl/codegen/client_callback.h",
1656  "grpcpp/impl/codegen/message_allocator.h",
1657  "grpcpp/impl/codegen/method_handler.h",
1658  "grpcpp/impl/codegen/rpc_service_method.h",
1659  "grpcpp/impl/codegen/server_callback.h",
1660  "grpcpp/impl/codegen/server_callback_handlers.h",
1661  "grpcpp/impl/codegen/server_context.h",
1662  "grpcpp/impl/codegen/service_type.h",
1663  "grpcpp/impl/codegen/sync_stream.h"};
1664  std::vector<std::string> headers(headers_strs, array_end(headers_strs));
1665  PrintIncludes(printer.get(), headers, params.use_system_headers,
1666  params.grpc_search_path);
1667 
1668  if (!file->package().empty()) {
1669  std::vector<std::string> parts = file->package_parts();
1670 
1671  for (auto part = parts.begin(); part != parts.end(); part++) {
1672  vars["part"] = *part;
1673  printer->Print(vars, "namespace $part$ {\n");
1674  }
1675  }
1676 
1677  printer->Print(vars, "\n");
1678  }
1679  return output;
1680 }
1681 
1682 void PrintSourceClientMethod(grpc_generator::Printer* printer,
1683  const grpc_generator::Method* method,
1684  std::map<std::string, std::string>* vars) {
1685  (*vars)["Method"] = method->name();
1686  (*vars)["Request"] = method->input_type_name();
1687  (*vars)["Response"] = method->output_type_name();
1688  struct {
1689  std::string prefix;
1690  std::string start; // bool literal expressed as string
1691  std::string method_params; // extra arguments to method
1692  std::string create_args; // extra arguments to creator
1693  } async_prefixes[] = {{"Async", "true", ", void* tag", ", tag"},
1694  {"PrepareAsync", "false", "", ", nullptr"}};
1695  if (method->NoStreaming()) {
1696  printer->Print(*vars,
1697  "::grpc::Status $ns$$Service$::Stub::$Method$("
1698  "::grpc::ClientContext* context, "
1699  "const $Request$& request, $Response$* response) {\n");
1700  printer->Print(*vars,
1701  " return ::grpc::internal::BlockingUnaryCall"
1702  "< $Request$, $Response$, ::grpc::protobuf::MessageLite, "
1703  "::grpc::protobuf::MessageLite>"
1704  "(channel_.get(), rpcmethod_$Method$_, "
1705  "context, request, response);\n}\n\n");
1706 
1707  printer->Print(*vars,
1708  "void $ns$$Service$::Stub::async::$Method$("
1709  "::grpc::ClientContext* context, "
1710  "const $Request$* request, $Response$* response, "
1711  "std::function<void(::grpc::Status)> f) {\n");
1712  printer->Print(*vars,
1713  " ::grpc::internal::CallbackUnaryCall"
1714  "< $Request$, $Response$, ::grpc::protobuf::MessageLite, "
1715  "::grpc::protobuf::MessageLite>"
1716  "(stub_->channel_.get(), stub_->rpcmethod_$Method$_, "
1717  "context, request, response, std::move(f));\n}\n\n");
1718 
1719  printer->Print(*vars,
1720  "void $ns$$Service$::Stub::async::$Method$("
1721  "::grpc::ClientContext* context, "
1722  "const $Request$* request, $Response$* response, "
1723  "::grpc::ClientUnaryReactor* reactor) {\n");
1724  printer->Print(*vars,
1725  " ::grpc::internal::ClientCallbackUnaryFactory::Create"
1726  "< ::grpc::protobuf::MessageLite, "
1727  "::grpc::protobuf::MessageLite>"
1728  "(stub_->channel_.get(), stub_->rpcmethod_$Method$_, "
1729  "context, request, response, reactor);\n}\n\n");
1730 
1731  printer->Print(*vars,
1732  "::grpc::ClientAsyncResponseReader< $Response$>* "
1733  "$ns$$Service$::Stub::PrepareAsync$Method$Raw(::grpc::"
1734  "ClientContext* context, "
1735  "const $Request$& request, "
1736  "::grpc::CompletionQueue* cq) {\n");
1737  printer->Print(*vars,
1738  " return "
1739  "::grpc::internal::ClientAsyncResponseReaderHelper::Create"
1740  "< $Response$, $Request$, ::grpc::protobuf::MessageLite, "
1741  "::grpc::protobuf::MessageLite>"
1742  "(channel_.get(), cq, rpcmethod_$Method$_, "
1743  "context, request);\n"
1744  "}\n\n");
1745  printer->Print(*vars,
1746  "::grpc::ClientAsyncResponseReader< $Response$>* "
1747  "$ns$$Service$::Stub::Async$Method$Raw(::grpc::"
1748  "ClientContext* context, "
1749  "const $Request$& request, "
1750  "::grpc::CompletionQueue* cq) {\n");
1751  printer->Print(*vars,
1752  " auto* result =\n"
1753  " this->PrepareAsync$Method$Raw(context, request, cq);\n"
1754  " result->StartCall();\n"
1755  " return result;\n"
1756  "}\n\n");
1757  } else if (ClientOnlyStreaming(method)) {
1758  printer->Print(*vars,
1759  "::grpc::ClientWriter< $Request$>* "
1760  "$ns$$Service$::Stub::$Method$Raw("
1761  "::grpc::ClientContext* context, $Response$* response) {\n");
1762  printer->Print(*vars,
1763  " return ::grpc::internal::ClientWriterFactory< "
1764  "$Request$>::Create("
1765  "channel_.get(), "
1766  "rpcmethod_$Method$_, "
1767  "context, response);\n"
1768  "}\n\n");
1769 
1770  printer->Print(*vars,
1771  "void $ns$$Service$::"
1772  "Stub::async::$Method$(::grpc::ClientContext* context, "
1773  "$Response$* response, "
1774  "::grpc::ClientWriteReactor< $Request$>* reactor) {\n");
1775  printer->Print(*vars,
1776  " ::grpc::internal::ClientCallbackWriterFactory< "
1777  "$Request$>::Create("
1778  "stub_->channel_.get(), "
1779  "stub_->rpcmethod_$Method$_, "
1780  "context, response, reactor);\n"
1781  "}\n\n");
1782 
1783  for (auto async_prefix : async_prefixes) {
1784  (*vars)["AsyncPrefix"] = async_prefix.prefix;
1785  (*vars)["AsyncStart"] = async_prefix.start;
1786  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
1787  (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
1788  printer->Print(*vars,
1789  "::grpc::ClientAsyncWriter< $Request$>* "
1790  "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw("
1791  "::grpc::ClientContext* context, $Response$* response, "
1792  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
1793  printer->Print(
1794  *vars,
1795  " return ::grpc::internal::ClientAsyncWriterFactory< $Request$>"
1796  "::Create(channel_.get(), cq, "
1797  "rpcmethod_$Method$_, "
1798  "context, response, $AsyncStart$$AsyncCreateArgs$);\n"
1799  "}\n\n");
1800  }
1801  } else if (ServerOnlyStreaming(method)) {
1802  printer->Print(
1803  *vars,
1804  "::grpc::ClientReader< $Response$>* "
1805  "$ns$$Service$::Stub::$Method$Raw("
1806  "::grpc::ClientContext* context, const $Request$& request) {\n");
1807  printer->Print(*vars,
1808  " return ::grpc::internal::ClientReaderFactory< "
1809  "$Response$>::Create("
1810  "channel_.get(), "
1811  "rpcmethod_$Method$_, "
1812  "context, request);\n"
1813  "}\n\n");
1814 
1815  printer->Print(*vars,
1816  "void $ns$$Service$::Stub::async::$Method$(::grpc::"
1817  "ClientContext* context, "
1818  "const $Request$* request, "
1819  "::grpc::ClientReadReactor< $Response$>* reactor) {\n");
1820  printer->Print(*vars,
1821  " ::grpc::internal::ClientCallbackReaderFactory< "
1822  "$Response$>::Create("
1823  "stub_->channel_.get(), "
1824  "stub_->rpcmethod_$Method$_, "
1825  "context, request, reactor);\n"
1826  "}\n\n");
1827 
1828  for (auto async_prefix : async_prefixes) {
1829  (*vars)["AsyncPrefix"] = async_prefix.prefix;
1830  (*vars)["AsyncStart"] = async_prefix.start;
1831  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
1832  (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
1833  printer->Print(
1834  *vars,
1835  "::grpc::ClientAsyncReader< $Response$>* "
1836  "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw("
1837  "::grpc::ClientContext* context, const $Request$& request, "
1838  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
1839  printer->Print(*vars,
1840  " return ::grpc::internal::ClientAsyncReaderFactory< "
1841  "$Response$>"
1842  "::Create(channel_.get(), cq, "
1843  "rpcmethod_$Method$_, "
1844  "context, request, $AsyncStart$$AsyncCreateArgs$);\n"
1845  "}\n\n");
1846  }
1847  } else if (method->BidiStreaming()) {
1848  printer->Print(
1849  *vars,
1850  "::grpc::ClientReaderWriter< $Request$, $Response$>* "
1851  "$ns$$Service$::Stub::$Method$Raw(::grpc::ClientContext* context) {\n");
1852  printer->Print(*vars,
1853  " return ::grpc::internal::ClientReaderWriterFactory< "
1854  "$Request$, $Response$>::Create("
1855  "channel_.get(), "
1856  "rpcmethod_$Method$_, "
1857  "context);\n"
1858  "}\n\n");
1859 
1860  printer->Print(*vars,
1861  "void $ns$$Service$::Stub::async::$Method$(::grpc::"
1862  "ClientContext* context, "
1863  "::grpc::ClientBidiReactor< $Request$,$Response$>* "
1864  "reactor) {\n");
1865  printer->Print(*vars,
1866  " ::grpc::internal::ClientCallbackReaderWriterFactory< "
1867  "$Request$,$Response$>::Create("
1868  "stub_->channel_.get(), "
1869  "stub_->rpcmethod_$Method$_, "
1870  "context, reactor);\n"
1871  "}\n\n");
1872 
1873  for (auto async_prefix : async_prefixes) {
1874  (*vars)["AsyncPrefix"] = async_prefix.prefix;
1875  (*vars)["AsyncStart"] = async_prefix.start;
1876  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
1877  (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
1878  printer->Print(*vars,
1879  "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
1880  "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(::grpc::"
1881  "ClientContext* context, "
1882  "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
1883  printer->Print(*vars,
1884  " return "
1885  "::grpc::internal::ClientAsyncReaderWriterFactory< "
1886  "$Request$, $Response$>::Create("
1887  "channel_.get(), cq, "
1888  "rpcmethod_$Method$_, "
1889  "context, $AsyncStart$$AsyncCreateArgs$);\n"
1890  "}\n\n");
1891  }
1892  }
1893 }
1894 
1895 void PrintSourceServerMethod(grpc_generator::Printer* printer,
1896  const grpc_generator::Method* method,
1897  std::map<std::string, std::string>* vars) {
1898  (*vars)["Method"] = method->name();
1899  (*vars)["Request"] = method->input_type_name();
1900  (*vars)["Response"] = method->output_type_name();
1901  if (method->NoStreaming()) {
1902  printer->Print(*vars,
1903  "::grpc::Status $ns$$Service$::Service::$Method$("
1904  "::grpc::ServerContext* context, "
1905  "const $Request$* request, $Response$* response) {\n");
1906  printer->Print(" (void) context;\n");
1907  printer->Print(" (void) request;\n");
1908  printer->Print(" (void) response;\n");
1909  printer->Print(
1910  " return ::grpc::Status("
1911  "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
1912  printer->Print("}\n\n");
1913  } else if (ClientOnlyStreaming(method)) {
1914  printer->Print(*vars,
1915  "::grpc::Status $ns$$Service$::Service::$Method$("
1916  "::grpc::ServerContext* context, "
1917  "::grpc::ServerReader< $Request$>* reader, "
1918  "$Response$* response) {\n");
1919  printer->Print(" (void) context;\n");
1920  printer->Print(" (void) reader;\n");
1921  printer->Print(" (void) response;\n");
1922  printer->Print(
1923  " return ::grpc::Status("
1924  "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
1925  printer->Print("}\n\n");
1926  } else if (ServerOnlyStreaming(method)) {
1927  printer->Print(*vars,
1928  "::grpc::Status $ns$$Service$::Service::$Method$("
1929  "::grpc::ServerContext* context, "
1930  "const $Request$* request, "
1931  "::grpc::ServerWriter< $Response$>* writer) {\n");
1932  printer->Print(" (void) context;\n");
1933  printer->Print(" (void) request;\n");
1934  printer->Print(" (void) writer;\n");
1935  printer->Print(
1936  " return ::grpc::Status("
1937  "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
1938  printer->Print("}\n\n");
1939  } else if (method->BidiStreaming()) {
1940  printer->Print(*vars,
1941  "::grpc::Status $ns$$Service$::Service::$Method$("
1942  "::grpc::ServerContext* context, "
1943  "::grpc::ServerReaderWriter< $Response$, $Request$>* "
1944  "stream) {\n");
1945  printer->Print(" (void) context;\n");
1946  printer->Print(" (void) stream;\n");
1947  printer->Print(
1948  " return ::grpc::Status("
1949  "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
1950  printer->Print("}\n\n");
1951  }
1952 }
1953 
1954 void PrintSourceService(grpc_generator::Printer* printer,
1955  const grpc_generator::Service* service,
1956  std::map<std::string, std::string>* vars) {
1957  (*vars)["Service"] = service->name();
1958 
1959  if (service->method_count() > 0) {
1960  printer->Print(*vars,
1961  "static const char* $prefix$$Service$_method_names[] = {\n");
1962  for (int i = 0; i < service->method_count(); ++i) {
1963  (*vars)["Method"] = service->method(i)->name();
1964  printer->Print(*vars, " \"/$Package$$Service$/$Method$\",\n");
1965  }
1966  printer->Print(*vars, "};\n\n");
1967  }
1968 
1969  printer->Print(*vars,
1970  "std::unique_ptr< $ns$$Service$::Stub> $ns$$Service$::NewStub("
1971  "const std::shared_ptr< ::grpc::ChannelInterface>& channel, "
1972  "const ::grpc::StubOptions& options) {\n"
1973  " (void)options;\n"
1974  " std::unique_ptr< $ns$$Service$::Stub> stub(new "
1975  "$ns$$Service$::Stub(channel, options));\n"
1976  " return stub;\n"
1977  "}\n\n");
1978  printer->Print(*vars,
1979  "$ns$$Service$::Stub::Stub(const std::shared_ptr< "
1980  "::grpc::ChannelInterface>& channel, const "
1981  "::grpc::StubOptions& options)\n");
1982  printer->Indent();
1983  printer->Print(": channel_(channel)");
1984  for (int i = 0; i < service->method_count(); ++i) {
1985  auto method = service->method(i);
1986  (*vars)["Method"] = method->name();
1987  (*vars)["Idx"] = as_string(i);
1988  if (method->NoStreaming()) {
1989  (*vars)["StreamingType"] = "NORMAL_RPC";
1990  // NOTE: There is no reason to consider streamed-unary as a separate
1991  // category here since this part is setting up the client-side stub
1992  // and this appears as a NORMAL_RPC from the client-side.
1993  } else if (ClientOnlyStreaming(method.get())) {
1994  (*vars)["StreamingType"] = "CLIENT_STREAMING";
1995  } else if (ServerOnlyStreaming(method.get())) {
1996  (*vars)["StreamingType"] = "SERVER_STREAMING";
1997  } else {
1998  (*vars)["StreamingType"] = "BIDI_STREAMING";
1999  }
2000  printer->Print(
2001  *vars,
2002  ", rpcmethod_$Method$_("
2003  "$prefix$$Service$_method_names[$Idx$], options.suffix_for_stats(),"
2004  "::grpc::internal::RpcMethod::$StreamingType$, "
2005  "channel"
2006  ")\n");
2007  }
2008  printer->Print("{}\n\n");
2009  printer->Outdent();
2010 
2011  for (int i = 0; i < service->method_count(); ++i) {
2012  (*vars)["Idx"] = as_string(i);
2013  PrintSourceClientMethod(printer, service->method(i).get(), vars);
2014  }
2015 
2016  printer->Print(*vars, "$ns$$Service$::Service::Service() {\n");
2017  printer->Indent();
2018  for (int i = 0; i < service->method_count(); ++i) {
2019  auto method = service->method(i);
2020  (*vars)["Idx"] = as_string(i);
2021  (*vars)["Method"] = method->name();
2022  (*vars)["Request"] = method->input_type_name();
2023  (*vars)["Response"] = method->output_type_name();
2024  if (method->NoStreaming()) {
2025  printer->Print(
2026  *vars,
2027  "AddMethod(new ::grpc::internal::RpcServiceMethod(\n"
2028  " $prefix$$Service$_method_names[$Idx$],\n"
2029  " ::grpc::internal::RpcMethod::NORMAL_RPC,\n"
2030  " new ::grpc::internal::RpcMethodHandler< $ns$$Service$::Service, "
2031  "$Request$, $Response$, ::grpc::protobuf::MessageLite, "
2032  "::grpc::protobuf::MessageLite>(\n"
2033  " []($ns$$Service$::Service* service,\n"
2034  " ::grpc::ServerContext* ctx,\n"
2035  " const $Request$* req,\n"
2036  " $Response$* resp) {\n"
2037  " return service->$Method$(ctx, req, resp);\n"
2038  " }, this)));\n");
2039  } else if (ClientOnlyStreaming(method.get())) {
2040  printer->Print(
2041  *vars,
2042  "AddMethod(new ::grpc::internal::RpcServiceMethod(\n"
2043  " $prefix$$Service$_method_names[$Idx$],\n"
2044  " ::grpc::internal::RpcMethod::CLIENT_STREAMING,\n"
2045  " new ::grpc::internal::ClientStreamingHandler< "
2046  "$ns$$Service$::Service, $Request$, $Response$>(\n"
2047  " []($ns$$Service$::Service* service,\n"
2048  " ::grpc::ServerContext* ctx,\n"
2049  " ::grpc::ServerReader<$Request$>* reader,\n"
2050  " $Response$* resp) {\n"
2051  " return service->$Method$(ctx, reader, resp);\n"
2052  " }, this)));\n");
2053  } else if (ServerOnlyStreaming(method.get())) {
2054  printer->Print(
2055  *vars,
2056  "AddMethod(new ::grpc::internal::RpcServiceMethod(\n"
2057  " $prefix$$Service$_method_names[$Idx$],\n"
2058  " ::grpc::internal::RpcMethod::SERVER_STREAMING,\n"
2059  " new ::grpc::internal::ServerStreamingHandler< "
2060  "$ns$$Service$::Service, $Request$, $Response$>(\n"
2061  " []($ns$$Service$::Service* service,\n"
2062  " ::grpc::ServerContext* ctx,\n"
2063  " const $Request$* req,\n"
2064  " ::grpc::ServerWriter<$Response$>* writer) {\n"
2065  " return service->$Method$(ctx, req, writer);\n"
2066  " }, this)));\n");
2067  } else if (method->BidiStreaming()) {
2068  printer->Print(*vars,
2069  "AddMethod(new ::grpc::internal::RpcServiceMethod(\n"
2070  " $prefix$$Service$_method_names[$Idx$],\n"
2071  " ::grpc::internal::RpcMethod::BIDI_STREAMING,\n"
2072  " new ::grpc::internal::BidiStreamingHandler< "
2073  "$ns$$Service$::Service, $Request$, $Response$>(\n"
2074  " []($ns$$Service$::Service* service,\n"
2075  " ::grpc::ServerContext* ctx,\n"
2076  " ::grpc::ServerReaderWriter<$Response$,\n"
2077  " $Request$>* stream) {\n"
2078  " return service->$Method$(ctx, stream);\n"
2079  " }, this)));\n");
2080  }
2081  }
2082  printer->Outdent();
2083  printer->Print(*vars, "}\n\n");
2084  printer->Print(*vars,
2085  "$ns$$Service$::Service::~Service() {\n"
2086  "}\n\n");
2087  for (int i = 0; i < service->method_count(); ++i) {
2088  (*vars)["Idx"] = as_string(i);
2089  PrintSourceServerMethod(printer, service->method(i).get(), vars);
2090  }
2091 }
2092 
2093 std::string GetSourceServices(grpc_generator::File* file,
2094  const Parameters& params) {
2095  std::string output;
2096  {
2097  // Scope the output stream so it closes and finalizes output to the string.
2098  auto printer = file->CreatePrinter(&output);
2099  std::map<std::string, std::string> vars;
2100  // Package string is empty or ends with a dot. It is used to fully qualify
2101  // method names.
2102  vars["Package"] = file->package();
2103  if (!file->package().empty()) {
2104  vars["Package"].append(".");
2105  }
2106  if (!params.services_namespace.empty()) {
2107  vars["ns"] = params.services_namespace + "::";
2108  vars["prefix"] = params.services_namespace;
2109  } else {
2110  vars["ns"] = "";
2111  vars["prefix"] = "";
2112  }
2113 
2114  for (int i = 0; i < file->service_count(); ++i) {
2115  PrintSourceService(printer.get(), file->service(i).get(), &vars);
2116  printer->Print("\n");
2117  }
2118  }
2119  return output;
2120 }
2121 
2122 std::string GetSourceEpilogue(grpc_generator::File* file,
2123  const Parameters& /*params*/) {
2124  std::string temp;
2125 
2126  if (!file->package().empty()) {
2127  std::vector<std::string> parts = file->package_parts();
2128 
2129  for (auto part = parts.begin(); part != parts.end(); part++) {
2130  temp.append("} // namespace ");
2131  temp.append(*part);
2132  temp.append("\n");
2133  }
2134  temp.append("\n");
2135  }
2136 
2137  return temp;
2138 }
2139 
2140 // TODO(mmukhi): Make sure we need parameters or not.
2141 std::string GetMockPrologue(grpc_generator::File* file,
2142  const Parameters& params) {
2143  std::string output;
2144  {
2145  // Scope the output stream so it closes and finalizes output to the string.
2146  auto printer = file->CreatePrinter(&output);
2147  std::map<std::string, std::string> vars;
2148 
2149  vars["filename"] = file->filename();
2150  vars["filename_base"] = file->filename_without_ext();
2151  vars["message_header_ext"] = params.message_header_extension.empty()
2152  ? kCppGeneratorMessageHeaderExt
2153  : params.message_header_extension;
2154  vars["service_header_ext"] = kCppGeneratorServiceHeaderExt;
2155 
2156  printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
2157  printer->Print(vars,
2158  "// If you make any local change, they will be lost.\n");
2159  printer->Print(vars, "// source: $filename$\n\n");
2160 
2161  printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
2162  printer->Print(vars, "#include \"$filename_base$$service_header_ext$\"\n");
2163  if (params.include_import_headers) {
2164  const std::vector<std::string> import_names = file->GetImportNames();
2165  for (const auto& import_name : import_names) {
2166  const std::string include_name = ImportInludeFromProtoName(import_name);
2167  printer->Print(vars, include_name.c_str());
2168  }
2169  printer->PrintRaw("\n");
2170  }
2171  printer->Print(vars, file->additional_headers().c_str());
2172  printer->Print(vars, "\n");
2173  }
2174  return output;
2175 }
2176 
2177 // TODO(mmukhi): Add client-stream and completion-queue headers.
2178 std::string GetMockIncludes(grpc_generator::File* file,
2179  const Parameters& params) {
2180  std::string output;
2181  {
2182  // Scope the output stream so it closes and finalizes output to the string.
2183  auto printer = file->CreatePrinter(&output);
2184  std::map<std::string, std::string> vars;
2185 
2186  static const char* headers_strs[] = {
2187  "grpcpp/impl/codegen/async_stream.h",
2188  "grpcpp/impl/codegen/sync_stream.h",
2189  };
2190  std::vector<std::string> headers(headers_strs, array_end(headers_strs));
2191  PrintIncludes(printer.get(), headers, params.use_system_headers,
2192  params.grpc_search_path);
2193 
2194  std::vector<std::string> gmock_header;
2195  if (params.gmock_search_path.empty()) {
2196  gmock_header.push_back("gmock/gmock.h");
2197  PrintIncludes(printer.get(), gmock_header, params.use_system_headers,
2198  params.grpc_search_path);
2199  } else {
2200  gmock_header.push_back("gmock.h");
2201  // We use local includes when a gmock_search_path is given
2202  PrintIncludes(printer.get(), gmock_header, false,
2203  params.gmock_search_path);
2204  }
2205 
2206  if (!file->package().empty()) {
2207  std::vector<std::string> parts = file->package_parts();
2208 
2209  for (auto part = parts.begin(); part != parts.end(); part++) {
2210  vars["part"] = *part;
2211  printer->Print(vars, "namespace $part$ {\n");
2212  }
2213  }
2214 
2215  printer->Print(vars, "\n");
2216  }
2217  return output;
2218 }
2219 
2220 void PrintMockClientMethods(grpc_generator::Printer* printer,
2221  const grpc_generator::Method* method,
2222  std::map<std::string, std::string>* vars) {
2223  (*vars)["Method"] = method->name();
2224  (*vars)["Request"] = method->input_type_name();
2225  (*vars)["Response"] = method->output_type_name();
2226 
2227  struct {
2228  std::string prefix;
2229  std::string method_params; // extra arguments to method
2230  int extra_method_param_count;
2231  } async_prefixes[] = {{"Async", ", void* tag", 1}, {"PrepareAsync", "", 0}};
2232 
2233  if (method->NoStreaming()) {
2234  printer->Print(
2235  *vars,
2236  "MOCK_METHOD3($Method$, ::grpc::Status(::grpc::ClientContext* context, "
2237  "const $Request$& request, $Response$* response));\n");
2238  for (auto async_prefix : async_prefixes) {
2239  (*vars)["AsyncPrefix"] = async_prefix.prefix;
2240  printer->Print(
2241  *vars,
2242  "MOCK_METHOD3($AsyncPrefix$$Method$Raw, "
2243  "::grpc::ClientAsyncResponseReaderInterface< $Response$>*"
2244  "(::grpc::ClientContext* context, const $Request$& request, "
2245  "::grpc::CompletionQueue* cq));\n");
2246  }
2247  } else if (ClientOnlyStreaming(method)) {
2248  printer->Print(
2249  *vars,
2250  "MOCK_METHOD2($Method$Raw, "
2251  "::grpc::ClientWriterInterface< $Request$>*"
2252  "(::grpc::ClientContext* context, $Response$* response));\n");
2253  for (auto async_prefix : async_prefixes) {
2254  (*vars)["AsyncPrefix"] = async_prefix.prefix;
2255  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
2256  (*vars)["MockArgs"] =
2257  std::to_string(3 + async_prefix.extra_method_param_count);
2258  printer->Print(*vars,
2259  "MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
2260  "::grpc::ClientAsyncWriterInterface< $Request$>*"
2261  "(::grpc::ClientContext* context, $Response$* response, "
2262  "::grpc::CompletionQueue* cq$AsyncMethodParams$));\n");
2263  }
2264  } else if (ServerOnlyStreaming(method)) {
2265  printer->Print(
2266  *vars,
2267  "MOCK_METHOD2($Method$Raw, "
2268  "::grpc::ClientReaderInterface< $Response$>*"
2269  "(::grpc::ClientContext* context, const $Request$& request));\n");
2270  for (auto async_prefix : async_prefixes) {
2271  (*vars)["AsyncPrefix"] = async_prefix.prefix;
2272  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
2273  (*vars)["MockArgs"] =
2274  std::to_string(3 + async_prefix.extra_method_param_count);
2275  printer->Print(
2276  *vars,
2277  "MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
2278  "::grpc::ClientAsyncReaderInterface< $Response$>*"
2279  "(::grpc::ClientContext* context, const $Request$& request, "
2280  "::grpc::CompletionQueue* cq$AsyncMethodParams$));\n");
2281  }
2282  } else if (method->BidiStreaming()) {
2283  printer->Print(
2284  *vars,
2285  "MOCK_METHOD1($Method$Raw, "
2286  "::grpc::ClientReaderWriterInterface< $Request$, $Response$>*"
2287  "(::grpc::ClientContext* context));\n");
2288  for (auto async_prefix : async_prefixes) {
2289  (*vars)["AsyncPrefix"] = async_prefix.prefix;
2290  (*vars)["AsyncMethodParams"] = async_prefix.method_params;
2291  (*vars)["MockArgs"] =
2292  std::to_string(2 + async_prefix.extra_method_param_count);
2293  printer->Print(
2294  *vars,
2295  "MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
2296  "::grpc::ClientAsyncReaderWriterInterface<$Request$, "
2297  "$Response$>*"
2298  "(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq"
2299  "$AsyncMethodParams$));\n");
2300  }
2301  }
2302 }
2303 
2304 void PrintMockService(grpc_generator::Printer* printer,
2305  const grpc_generator::Service* service,
2306  std::map<std::string, std::string>* vars) {
2307  (*vars)["Service"] = service->name();
2308 
2309  printer->Print(*vars,
2310  "class Mock$Service$Stub : public $Service$::StubInterface {\n"
2311  " public:\n");
2312  printer->Indent();
2313  for (int i = 0; i < service->method_count(); ++i) {
2314  PrintMockClientMethods(printer, service->method(i).get(), vars);
2315  }
2316  printer->Outdent();
2317  printer->Print("};\n");
2318 }
2319 
2320 std::string GetMockServices(grpc_generator::File* file,
2321  const Parameters& params) {
2322  std::string output;
2323  {
2324  // Scope the output stream so it closes and finalizes output to the string.
2325  auto printer = file->CreatePrinter(&output);
2326  std::map<std::string, std::string> vars;
2327  // Package string is empty or ends with a dot. It is used to fully qualify
2328  // method names.
2329  vars["Package"] = file->package();
2330  if (!file->package().empty()) {
2331  vars["Package"].append(".");
2332  }
2333 
2334  if (!params.services_namespace.empty()) {
2335  vars["services_namespace"] = params.services_namespace;
2336  printer->Print(vars, "\nnamespace $services_namespace$ {\n\n");
2337  }
2338 
2339  for (int i = 0; i < file->service_count(); i++) {
2340  PrintMockService(printer.get(), file->service(i).get(), &vars);
2341  printer->Print("\n");
2342  }
2343 
2344  if (!params.services_namespace.empty()) {
2345  printer->Print(vars, "} // namespace $services_namespace$\n\n");
2346  }
2347  }
2348  return output;
2349 }
2350 
2351 std::string GetMockEpilogue(grpc_generator::File* file,
2352  const Parameters& /*params*/) {
2353  std::string temp;
2354 
2355  if (!file->package().empty()) {
2356  std::vector<std::string> parts = file->package_parts();
2357 
2358  for (auto part = parts.begin(); part != parts.end(); part++) {
2359  temp.append("} // namespace ");
2360  temp.append(*part);
2361  temp.append("\n");
2362  }
2363  temp.append("\n");
2364  }
2365 
2366  return temp;
2367 }
2368 
2369 } // namespace grpc_cpp_generator
grpc_cpp_generator::PrintHeaderClientMethodCallbackInterfacesStart
void PrintHeaderClientMethodCallbackInterfacesStart(grpc_generator::Printer *printer, std::map< std::string, std::string > *)
Definition: src/compiler/cpp_generator.cc:575
grpc_cpp_generator::PrintHeaderClientMethodInterfaces
void PrintHeaderClientMethodInterfaces(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars, bool is_public)
Definition: src/compiler/cpp_generator.cc:189
_gevent_test_main.result
result
Definition: _gevent_test_main.py:96
grpc_cpp_generator::PrintHeaderServerAsyncMethodsHelper
void PrintHeaderServerAsyncMethodsHelper(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:761
grpc_cpp_generator::GetMockEpilogue
std::string GetMockEpilogue(grpc_generator::File *file, const Parameters &)
Definition: src/compiler/cpp_generator.cc:2351
filename
const char * filename
Definition: bloaty/third_party/zlib/contrib/minizip/ioapi.h:135
fix_build_deps.temp
temp
Definition: fix_build_deps.py:488
gen_build_yaml.out
dictionary out
Definition: src/benchmark/gen_build_yaml.py:24
grpc_cpp_generator::PrintHeaderServerMethodCallback
void PrintHeaderServerMethodCallback(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:964
grpc_generator::Service
Definition: schema_interface.h:80
fix_build_deps.c
list c
Definition: fix_build_deps.py:490
grpc_cpp_generator::PrintHeaderServerMethodGeneric
void PrintHeaderServerMethodGeneric(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1227
grpc_generator::Printer::Print
virtual void Print(const std::map< std::string, std::string > &vars, const char *template_string)=0
grpc_generator::File
Definition: schema_interface.h:102
grpc_generator::Printer::Outdent
virtual void Outdent()=0
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
grpc_cpp_generator::PrintHeaderService
void PrintHeaderService(grpc_generator::Printer *printer, const grpc_generator::Service *service, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1329
grpc_cpp_generator::PrintHeaderClientMethodCallbackInterfacesEnd
void PrintHeaderClientMethodCallbackInterfacesEnd(grpc_generator::Printer *printer, std::map< std::string, std::string > *)
Definition: src/compiler/cpp_generator.cc:626
grpc_cpp_generator::PrintHeaderClientMethodCallbackInterfaces
void PrintHeaderClientMethodCallbackInterfaces(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:590
file
Definition: bloaty/third_party/zlib/examples/gzappend.c:170
grpc_cpp_generator::GetHeaderPrologue
std::string GetHeaderPrologue(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:85
grpc_cpp_generator::Parameters::services_namespace
std::string services_namespace
Definition: src/compiler/cpp_generator.h:52
grpc_cpp_generator::PrintHeaderClientMethodCallback
void PrintHeaderClientMethodCallback(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:659
T
#define T(upbtypeconst, upbtype, ctype, default_value)
grpc_cpp_generator
Definition: src/compiler/config.h:61
grpc_generator::Method
Definition: schema_interface.h:54
grpc_cpp_generator::ImportInludeFromProtoName
std::string ImportInludeFromProtoName(const std::string &proto_name)
Definition: src/compiler/cpp_generator.cc:120
grpc_cpp_generator::PrintHeaderClientMethod
void PrintHeaderClientMethod(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars, bool is_public)
Definition: src/compiler/cpp_generator.cc:388
grpc_cpp_generator::PrintHeaderClientMethodData
void PrintHeaderClientMethodData(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:716
start
static uint64_t start
Definition: benchmark-pound.c:74
grpc_cpp_generator::PrintMockClientMethods
void PrintMockClientMethods(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:2220
grpc_cpp_generator::GetHeaderServices
std::string GetHeaderServices(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:1555
array
Definition: undname.c:101
gmock_output_test.output
output
Definition: bloaty/third_party/googletest/googlemock/test/gmock_output_test.py:175
grpc_cpp_generator::kCppGeneratorServiceHeaderExt
static const char *const kCppGeneratorServiceHeaderExt
Definition: src/compiler/config.h:64
cpp_generator.h
grpc_cpp_generator::Parameters
Definition: src/compiler/cpp_generator.h:50
grpc_cpp_generator::GetMockIncludes
std::string GetMockIncludes(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:2178
grpc_generator::Printer::Indent
virtual void Indent()=0
grpc_cpp_generator::GetSourceServices
std::string GetSourceServices(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:2093
grpc_cpp_generator::PrintHeaderServerMethodAsync
void PrintHeaderServerMethodAsync(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:856
x
int x
Definition: bloaty/third_party/googletest/googlemock/test/gmock-matchers_test.cc:3610
grpc_cpp_generator::GetSourceEpilogue
std::string GetSourceEpilogue(grpc_generator::File *file, const Parameters &)
Definition: src/compiler/cpp_generator.cc:2122
grpc_cpp_generator::PrintHeaderClientMethodCallbackEnd
void PrintHeaderClientMethodCallbackEnd(grpc_generator::Printer *printer, std::map< std::string, std::string > *)
Definition: src/compiler/cpp_generator.cc:696
grpc_cpp_generator::PrintHeaderServerMethodSplitStreaming
void PrintHeaderServerMethodSplitStreaming(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1172
grpc_cpp_generator::kCppGeneratorMessageHeaderExt
static const char *const kCppGeneratorMessageHeaderExt
Definition: src/compiler/config.h:63
grpc_cpp_generator::Parameters::message_header_extension
std::string message_header_extension
Definition: src/compiler/cpp_generator.h:64
grpc_cpp_generator::Parameters::include_import_headers
bool include_import_headers
Definition: src/compiler/cpp_generator.h:66
grpc_cpp_generator::PrintHeaderServerMethodRaw
void PrintHeaderServerMethodRaw(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1298
grpc_cpp_generator::PrintSourceService
void PrintSourceService(grpc_generator::Printer *printer, const grpc_generator::Service *service, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1954
absl::chars_format::hex
@ hex
grpc_cpp_generator::Parameters::grpc_search_path
std::string grpc_search_path
Definition: src/compiler/cpp_generator.h:56
grpc_cpp_generator::PrintMockService
void PrintMockService(grpc_generator::Printer *printer, const grpc_generator::Service *service, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:2304
N
#define N
Definition: sync_test.cc:37
grpc_cpp_generator::PrintHeaderServerMethodRawCallback
void PrintHeaderServerMethodRawCallback(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1046
google::protobuf::compiler::cpp::FilenameIdentifier
std::string FilenameIdentifier(const std::string &filename)
Definition: bloaty/third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_helpers.cc:698
grpc_cpp_generator::GetSourcePrologue
std::string GetSourcePrologue(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:1615
grpc_cpp_generator::GetHeaderEpilogue
std::string GetHeaderEpilogue(grpc_generator::File *file, const Parameters &)
Definition: src/compiler/cpp_generator.cc:1586
grpc_cpp_generator::GetMockServices
std::string GetMockServices(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:2320
grpc_cpp_generator::Parameters::gmock_search_path
std::string gmock_search_path
Definition: src/compiler/cpp_generator.h:60
grpc_generator::Printer
Definition: schema_interface.h:89
grpc_cpp_generator::PrintIncludes
void PrintIncludes(grpc_generator::Printer *printer, const std::vector< std::string > &headers, bool use_system_headers, const std::string &search_path)
Definition: src/compiler/cpp_generator.cc:64
prefix
static const char prefix[]
Definition: head_of_line_blocking.cc:28
grpc_cpp_generator::PrintHeaderServerMethodStreamedUnary
void PrintHeaderServerMethodStreamedUnary(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1118
search_path
static WCHAR * search_path(const WCHAR *file, WCHAR *cwd, const WCHAR *path)
Definition: win/process.c:340
grpc_cpp_generator::array_end
T * array_end(T(&array)[N])
Definition: src/compiler/cpp_generator.cc:60
grpc_cpp_generator::Parameters::use_system_headers
bool use_system_headers
Definition: src/compiler/cpp_generator.h:54
as_string
std::string as_string(const T &val)
Definition: json_run_localhost.cc:45
grpc_cpp_generator::PrintHeaderClientMethodCallbackStart
void PrintHeaderClientMethodCallbackStart(grpc_generator::Printer *printer, std::map< std::string, std::string > *)
Definition: src/compiler/cpp_generator.cc:649
grpc_cpp_generator::PrintHeaderServerMethodSync
void PrintHeaderServerMethodSync(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:724
grpc_cpp_generator::GetMockPrologue
std::string GetMockPrologue(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:2141
service
__attribute__((deprecated("Please use GRPCProtoMethod."))) @interface ProtoMethod NSString * service
Definition: ProtoMethod.h:25
grpc_cpp_generator::PrintHeaderServerCallbackMethodsHelper
void PrintHeaderServerCallbackMethodsHelper(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:891
grpc_cpp_generator::GetSourceIncludes
std::string GetSourceIncludes(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:1642
method
NSString * method
Definition: ProtoMethod.h:28
to_string
static bool to_string(zval *from)
Definition: protobuf/php/ext/google/protobuf/convert.c:333
grpc_cpp_generator::GetHeaderIncludes
std::string GetHeaderIncludes(grpc_generator::File *file, const Parameters &params)
Definition: src/compiler/cpp_generator.cc:126
grpc_cpp_generator::PrintSourceClientMethod
void PrintSourceClientMethod(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1682
grpc_cpp_generator::Parameters::additional_header_includes
std::vector< std::string > additional_header_includes
Definition: src/compiler/cpp_generator.h:62
grpc_cpp_generator::PrintSourceServerMethod
void PrintSourceServerMethod(grpc_generator::Printer *printer, const grpc_generator::Method *method, std::map< std::string, std::string > *vars)
Definition: src/compiler/cpp_generator.cc:1895
i
uint64_t i
Definition: abseil-cpp/absl/container/btree_benchmark.cc:230

grpc
Author(s):
autogenerated on Thu Mar 13 2025 02:58:58