Rooba
/
flatbuffers
mirror of https://github.com/google/flatbuffers.git
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

updated cpp_generator.cc to be compatible with the latest grpc version (#4551) 

* updateed cpp_generator.cc to be compatible with the latest grpc version

* preserved the original license
This commit is contained in:
Yuri Finkelstein 2017-12-18 12:17:59 -10:00 committed by Wouter van Oortmerssen
parent c1901f2c01
commit dd73b53e28
1 changed files with 392 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

605
grpc/src/compiler/cpp_generator.cc
View File

@ -34,6 +34,7 @@
#include <map> #include <map>
#include "src/compiler/cpp_generator.h" #include "src/compiler/cpp_generator.h"
#include "flatbuffers/util.h"
#include <sstream> #include <sstream>
@ -127,8 +128,8 @@ grpc::string GetHeaderPrologue(grpc_generator::File *file,
printer->Print(vars, "#ifndef GRPC_$filename_identifier$__INCLUDED\n"); printer->Print(vars, "#ifndef GRPC_$filename_identifier$__INCLUDED\n");
printer->Print(vars, "#define GRPC_$filename_identifier$__INCLUDED\n"); printer->Print(vars, "#define GRPC_$filename_identifier$__INCLUDED\n");
printer->Print(vars, "\n"); printer->Print(vars, "\n");
printer->Print(vars, file->additional_headers().c_str());
printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n"); printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
printer->Print(vars, file->additional_headers().c_str());
printer->Print(vars, "\n"); printer->Print(vars, "\n");
} }
return output; return output;
@ -183,25 +184,38 @@ void PrintHeaderClientMethodInterfaces(
(*vars)["Request"] = method->input_type_name(); (*vars)["Request"] = method->input_type_name();
(*vars)["Response"] = method->output_type_name(); (*vars)["Response"] = method->output_type_name();
struct {
grpc::string prefix;
grpc::string method_params; // extra arguments to method
grpc::string raw_args; // extra arguments to raw version of method
} async_prefixes[] = {{"Async", ", void* tag", ", tag"},
{"PrepareAsync", "", ""}};
if (is_public) { if (is_public) {
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
"virtual ::grpc::Status $Method$(::grpc::ClientContext* context, " "virtual ::grpc::Status $Method$(::grpc::ClientContext* context, "
"const $Request$& request, $Response$* response) = 0;\n"); "const $Request$& request, $Response$* response) = 0;\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"std::unique_ptr< " auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncResponseReaderInterface< $Response$>> " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$(::grpc::ClientContext* context, " printer->Print(
"const $Request$& request, " *vars,
"::grpc::CompletionQueue* cq) {\n"); "std::unique_ptr< "
printer->Indent(); "::grpc::ClientAsyncResponseReaderInterface< $Response$>> "
printer->Print(*vars, "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
"return std::unique_ptr< " "const $Request$& request, "
"::grpc::ClientAsyncResponseReaderInterface< $Response$>>(" "::grpc::CompletionQueue* cq) {\n");
"Async$Method$Raw(context, request, cq));\n"); printer->Indent();
printer->Outdent(); printer->Print(
printer->Print("}\n"); *vars,
"return std::unique_ptr< "
"::grpc::ClientAsyncResponseReaderInterface< $Response$>>("
"$AsyncPrefix$$Method$Raw(context, request, cq));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
@ -215,19 +229,27 @@ void PrintHeaderClientMethodInterfaces(
"($Method$Raw(context, response));\n"); "($Method$Raw(context, response));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>" (*vars)["AsyncPrefix"] = async_prefix.prefix;
" Async$Method$(::grpc::ClientContext* context, $Response$* " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"response, " (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
"::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Print(
printer->Indent(); *vars,
printer->Print(*vars, "std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>"
"return std::unique_ptr< " " $AsyncPrefix$$Method$(::grpc::ClientContext* context, "
"::grpc::ClientAsyncWriterInterface< $Request$>>(" "$Response$* "
"Async$Method$Raw(context, response, cq, tag));\n"); "response, "
printer->Outdent(); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Print("}\n"); printer->Indent();
printer->Print(*vars,
"return std::unique_ptr< "
"::grpc::ClientAsyncWriterInterface< $Request$>>("
"$AsyncPrefix$$Method$Raw(context, response, "
"cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
@ -241,19 +263,26 @@ void PrintHeaderClientMethodInterfaces(
"($Method$Raw(context, request));\n"); "($Method$Raw(context, request));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"std::unique_ptr< ::grpc::ClientAsyncReaderInterface< $Response$>> " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$(" (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::ClientContext* context, const $Request$& request, " (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
"::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Print(
printer->Indent(); *vars,
printer->Print(*vars, "std::unique_ptr< ::grpc::ClientAsyncReaderInterface< $Response$>> "
"return std::unique_ptr< " "$AsyncPrefix$$Method$("
"::grpc::ClientAsyncReaderInterface< $Response$>>(" "::grpc::ClientContext* context, const $Request$& request, "
"Async$Method$Raw(context, request, cq, tag));\n"); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Outdent(); printer->Indent();
printer->Print("}\n"); printer->Print(
*vars,
"return std::unique_ptr< "
"::grpc::ClientAsyncReaderInterface< $Response$>>("
"$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"std::unique_ptr< ::grpc::ClientReaderWriterInterface< " "std::unique_ptr< ::grpc::ClientReaderWriterInterface< "
@ -267,61 +296,88 @@ void PrintHeaderClientMethodInterfaces(
"$Method$Raw(context));\n"); "$Method$Raw(context));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"std::unique_ptr< " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>> " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"Async$Method$(::grpc::ClientContext* context, " (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
"::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Print(
printer->Indent(); *vars,
printer->Print( "std::unique_ptr< "
*vars, "::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>> "
"return std::unique_ptr< " "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
"::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>>(" "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
"Async$Method$Raw(context, cq, tag));\n"); printer->Indent();
printer->Outdent(); printer->Print(
printer->Print("}\n"); *vars,
"return std::unique_ptr< "
"::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>>("
"$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} }
} else { } else {
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$Raw(::grpc::ClientContext* context, " printer->Print(
"const $Request$& request, " *vars,
"::grpc::CompletionQueue* cq) = 0;\n"); "virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* "
"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
"const $Request$& request, "
"::grpc::CompletionQueue* cq) = 0;\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
"virtual ::grpc::ClientWriterInterface< $Request$>*" "virtual ::grpc::ClientWriterInterface< $Request$>*"
" $Method$Raw(" " $Method$Raw("
"::grpc::ClientContext* context, $Response$* response) = 0;\n"); "::grpc::ClientContext* context, $Response$* response) = 0;\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"virtual ::grpc::ClientAsyncWriterInterface< $Request$>*" auto& async_prefix = async_prefixes[i];
" Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"$Response$* response, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag) = 0;\n"); printer->Print(
*vars,
"virtual ::grpc::ClientAsyncWriterInterface< $Request$>*"
" $AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
"$Response$* response, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
"virtual ::grpc::ClientReaderInterface< $Response$>* $Method$Raw(" "virtual ::grpc::ClientReaderInterface< $Response$>* $Method$Raw("
"::grpc::ClientContext* context, const $Request$& request) = 0;\n"); "::grpc::ClientContext* context, const $Request$& request) = 0;\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"virtual ::grpc::ClientAsyncReaderInterface< $Response$>* " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$Raw(" (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::ClientContext* context, const $Request$& request, " printer->Print(
"::grpc::CompletionQueue* cq, void* tag) = 0;\n"); *vars,
"virtual ::grpc::ClientAsyncReaderInterface< $Response$>* "
"$AsyncPrefix$$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"virtual ::grpc::ClientReaderWriterInterface< $Request$, " "virtual ::grpc::ClientReaderWriterInterface< $Request$, "
"$Response$>* " "$Response$>* "
"$Method$Raw(::grpc::ClientContext* context) = 0;\n"); "$Method$Raw(::grpc::ClientContext* context) = 0;\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"virtual ::grpc::ClientAsyncReaderWriterInterface< " auto& async_prefix = async_prefixes[i];
"$Request$, $Response$>* " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag) = 0;\n"); printer->Print(
*vars,
"virtual ::grpc::ClientAsyncReaderWriterInterface< "
"$Request$, $Response$>* "
"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\n");
}
} }
} }
} }
@ -333,25 +389,36 @@ void PrintHeaderClientMethod(grpc_generator::Printer *printer,
(*vars)["Method"] = method->name(); (*vars)["Method"] = method->name();
(*vars)["Request"] = method->input_type_name(); (*vars)["Request"] = method->input_type_name();
(*vars)["Response"] = method->output_type_name(); (*vars)["Response"] = method->output_type_name();
struct {
grpc::string prefix;
grpc::string method_params; // extra arguments to method
grpc::string raw_args; // extra arguments to raw version of method
} async_prefixes[] = {{"Async", ", void* tag", ", tag"},
{"PrepareAsync", "", ""}};
if (is_public) { if (is_public) {
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
"::grpc::Status $Method$(::grpc::ClientContext* context, " "::grpc::Status $Method$(::grpc::ClientContext* context, "
"const $Request$& request, $Response$* response) override;\n"); "const $Request$& request, $Response$* response) override;\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$(::grpc::ClientContext* context, " printer->Print(
"const $Request$& request, " *vars,
"::grpc::CompletionQueue* cq) {\n"); "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
printer->Indent(); "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
printer->Print(*vars, "const $Request$& request, "
"return std::unique_ptr< " "::grpc::CompletionQueue* cq) {\n");
"::grpc::ClientAsyncResponseReader< $Response$>>(" printer->Indent();
"Async$Method$Raw(context, request, cq));\n"); printer->Print(*vars,
printer->Outdent(); "return std::unique_ptr< "
printer->Print("}\n"); "::grpc::ClientAsyncResponseReader< $Response$>>("
"$AsyncPrefix$$Method$Raw(context, request, cq));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
@ -364,18 +431,25 @@ void PrintHeaderClientMethod(grpc_generator::Printer *printer,
"($Method$Raw(context, response));\n"); "($Method$Raw(context, response));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>" auto& async_prefix = async_prefixes[i];
" Async$Method$(::grpc::ClientContext* context, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"$Response$* response, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag) {\n"); (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
printer->Indent(); printer->Print(*vars,
printer->Print( "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>"
*vars, " $AsyncPrefix$$Method$(::grpc::ClientContext* context, "
"return std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>(" "$Response$* response, "
"Async$Method$Raw(context, response, cq, tag));\n"); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Outdent(); printer->Indent();
printer->Print("}\n"); printer->Print(
*vars,
"return std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>("
"$AsyncPrefix$$Method$Raw(context, response, "
"cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
@ -389,19 +463,25 @@ void PrintHeaderClientMethod(grpc_generator::Printer *printer,
"($Method$Raw(context, request));\n"); "($Method$Raw(context, request));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$(" (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::ClientContext* context, const $Request$& request, " (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
"::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Print(
printer->Indent(); *vars,
printer->Print( "std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> "
*vars, "$AsyncPrefix$$Method$("
"return std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>>(" "::grpc::ClientContext* context, const $Request$& request, "
"Async$Method$Raw(context, request, cq, tag));\n"); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Outdent(); printer->Indent();
printer->Print("}\n"); printer->Print(
*vars,
"return std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>>("
"$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
@ -414,53 +494,85 @@ void PrintHeaderClientMethod(grpc_generator::Printer *printer,
"$Method$Raw(context));\n"); "$Method$Raw(context));\n");
printer->Outdent(); printer->Outdent();
printer->Print("}\n"); printer->Print("}\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"std::unique_ptr< ::grpc::ClientAsyncReaderWriter< " auto& async_prefix = async_prefixes[i];
"$Request$, $Response$>> " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"Async$Method$(::grpc::ClientContext* context, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag) {\n"); (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
printer->Indent(); printer->Print(*vars,
printer->Print(*vars, "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
"return std::unique_ptr< " "$Request$, $Response$>> "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>(" "$AsyncPrefix$$Method$(::grpc::ClientContext* context, "
"Async$Method$Raw(context, cq, tag));\n"); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Outdent(); printer->Indent();
printer->Print("}\n"); printer->Print(
*vars,
"return std::unique_ptr< "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>("
"$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\n");
printer->Outdent();
printer->Print("}\n");
}
} }
} else { } else {
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"::grpc::ClientAsyncResponseReader< $Response$>* " auto& async_prefix = async_prefixes[i];
"Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"const $Request$& request, " printer->Print(
"::grpc::CompletionQueue* cq) override;\n"); *vars,
"::grpc::ClientAsyncResponseReader< $Response$>* "
"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
"const $Request$& request, "
"::grpc::CompletionQueue* cq) override;\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientWriter< $Request$>* $Method$Raw(" "::grpc::ClientWriter< $Request$>* $Method$Raw("
"::grpc::ClientContext* context, $Response$* response) " "::grpc::ClientContext* context, $Response$* response) "
"override;\n"); "override;\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw(" auto& async_prefix = async_prefixes[i];
"::grpc::ClientContext* context, $Response$* response, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::CompletionQueue* cq, void* tag) override;\n"); (*vars)["AsyncMethodParams"] = async_prefix.method_params;
(*vars)["AsyncRawArgs"] = async_prefix.raw_args;
printer->Print(
*vars,
"::grpc::ClientAsyncWriter< $Request$>* $AsyncPrefix$$Method$Raw("
"::grpc::ClientContext* context, $Response$* response, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientReader< $Response$>* $Method$Raw(" "::grpc::ClientReader< $Response$>* $Method$Raw("
"::grpc::ClientContext* context, const $Request$& request)" "::grpc::ClientContext* context, const $Request$& request)"
" override;\n"); " override;\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw(" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::ClientContext* context, const $Request$& request, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag) override;\n"); (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
printer->Print(
*vars,
"::grpc::ClientAsyncReader< $Response$>* $AsyncPrefix$$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientReaderWriter< $Request$, $Response$>* " "::grpc::ClientReaderWriter< $Request$, $Response$>* "
"$Method$Raw(::grpc::ClientContext* context) override;\n"); "$Method$Raw(::grpc::ClientContext* context) override;\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* " auto& async_prefix = async_prefixes[i];
"Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::CompletionQueue* cq, void* tag) override;\n"); (*vars)["AsyncMethodParams"] = async_prefix.method_params;
(*vars)["AsyncRawArgs"] = async_prefix.raw_args;
printer->Print(
*vars,
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\n");
}
} }
} }
} }
@ -1095,6 +1207,13 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
(*vars)["Method"] = method->name(); (*vars)["Method"] = method->name();
(*vars)["Request"] = method->input_type_name(); (*vars)["Request"] = method->input_type_name();
(*vars)["Response"] = method->output_type_name(); (*vars)["Response"] = method->output_type_name();
struct {
grpc::string prefix;
grpc::string start; // bool literal expressed as string
grpc::string method_params; // extra arguments to method
grpc::string create_args; // extra arguments to creator
} async_prefixes[] = {{"Async", "true", ", void* tag", ", tag"},
{"PrepareAsync", "false", "", ", nullptr"}};
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::Status $ns$$Service$::Stub::$Method$(" "::grpc::Status $ns$$Service$::Stub::$Method$("
@ -1105,19 +1224,24 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
"rpcmethod_$Method$_, " "rpcmethod_$Method$_, "
"context, request, response);\n" "context, request, response);\n"
"}\n\n"); "}\n\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncResponseReader< $Response$>* " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncStart"] = async_prefix.start;
"const $Request$& request, " printer->Print(*vars,
"::grpc::CompletionQueue* cq) {\n"); "::grpc::ClientAsyncResponseReader< $Response$>* "
printer->Print(*vars, "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(::grpc::"
" return " "ClientContext* context, "
"::grpc::ClientAsyncResponseReader< $Response$>::Create(" "const $Request$& request, "
"channel_.get(), cq, " "::grpc::CompletionQueue* cq) {\n");
"rpcmethod_$Method$_, " printer->Print(*vars,
"context, request);\n" " return "
"}\n\n"); "::grpc::ClientAsyncResponseReader< $Response$>::Create("
"channel_.get(), cq, "
"rpcmethod_$Method$_, "
"context, request, $AsyncStart$);\n"
"}\n\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print(*vars, printer->Print(*vars,
"::grpc::ClientWriter< $Request$>* " "::grpc::ClientWriter< $Request$>* "
@ -1129,17 +1253,24 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
"rpcmethod_$Method$_, " "rpcmethod_$Method$_, "
"context, response);\n" "context, response);\n"
"}\n\n"); "}\n\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"::grpc::ClientAsyncWriter< $Request$>* " auto& async_prefix = async_prefixes[i];
"$ns$$Service$::Stub::Async$Method$Raw(" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::ClientContext* context, $Response$* response, " (*vars)["AsyncStart"] = async_prefix.start;
"::grpc::CompletionQueue* cq, void* tag) {\n"); (*vars)["AsyncMethodParams"] = async_prefix.method_params;
printer->Print(*vars, (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
" return ::grpc::ClientAsyncWriter< $Request$>::Create(" printer->Print(*vars,
"channel_.get(), cq, " "::grpc::ClientAsyncWriter< $Request$>* "
"rpcmethod_$Method$_, " "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw("
"context, response, tag);\n" "::grpc::ClientContext* context, $Response$* response, "
"}\n\n"); "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Print(*vars,
" return ::grpc::ClientAsyncWriter< $Request$>::Create("
"channel_.get(), cq, "
"rpcmethod_$Method$_, "
"context, response, $AsyncStart$$AsyncCreateArgs$);\n"
"}\n\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
@ -1152,17 +1283,25 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
"rpcmethod_$Method$_, " "rpcmethod_$Method$_, "
"context, request);\n" "context, request);\n"
"}\n\n"); "}\n\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"::grpc::ClientAsyncReader< $Response$>* " auto& async_prefix = async_prefixes[i];
"$ns$$Service$::Stub::Async$Method$Raw(" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::ClientContext* context, const $Request$& request, " (*vars)["AsyncStart"] = async_prefix.start;
"::grpc::CompletionQueue* cq, void* tag) {\n"); (*vars)["AsyncMethodParams"] = async_prefix.method_params;
printer->Print(*vars, (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
" return ::grpc::ClientAsyncReader< $Response$>::Create(" printer->Print(
"channel_.get(), cq, " *vars,
"rpcmethod_$Method$_, " "::grpc::ClientAsyncReader< $Response$>* "
"context, request, tag);\n" "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw("
"}\n\n"); "::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
printer->Print(*vars,
" return ::grpc::ClientAsyncReader< $Response$>::Create("
"channel_.get(), cq, "
"rpcmethod_$Method$_, "
"context, request, $AsyncStart$$AsyncCreateArgs$);\n"
"}\n\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
@ -1175,19 +1314,26 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
"rpcmethod_$Method$_, " "rpcmethod_$Method$_, "
"context);\n" "context);\n"
"}\n\n"); "}\n\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, " (*vars)["AsyncStart"] = async_prefix.start;
"::grpc::CompletionQueue* cq, void* tag) {\n"); (*vars)["AsyncMethodParams"] = async_prefix.method_params;
printer->Print( (*vars)["AsyncCreateArgs"] = async_prefix.create_args;
*vars, printer->Print(*vars,
" return " "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>::Create(" "$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(::grpc::"
"channel_.get(), cq, " "ClientContext* context, "
"rpcmethod_$Method$_, " "::grpc::CompletionQueue* cq$AsyncMethodParams$) {\n");
"context, tag);\n" printer->Print(
"}\n\n"); *vars,
" return "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>::Create("
"channel_.get(), cq, "
"rpcmethod_$Method$_, "
"context, $AsyncStart$$AsyncCreateArgs$);\n"
"}\n\n");
}
} }
} }
@ -1478,50 +1624,83 @@ void PrintMockClientMethods(grpc_generator::Printer *printer,
(*vars)["Request"] = method->input_type_name(); (*vars)["Request"] = method->input_type_name();
(*vars)["Response"] = method->output_type_name(); (*vars)["Response"] = method->output_type_name();
struct {
grpc::string prefix;
grpc::string method_params; // extra arguments to method
int extra_method_param_count;
} async_prefixes[] = {{"Async", ", void* tag", 1}, {"PrepareAsync", "", 0}};
if (method->NoStreaming()) { if (method->NoStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
"MOCK_METHOD3($Method$, ::grpc::Status(::grpc::ClientContext* context, " "MOCK_METHOD3($Method$, ::grpc::Status(::grpc::ClientContext* context, "
"const $Request$& request, $Response$* response));\n"); "const $Request$& request, $Response$* response));\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"MOCK_METHOD3(Async$Method$Raw, " auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncResponseReaderInterface< $Response$>*" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"(::grpc::ClientContext* context, const $Request$& request, " printer->Print(
"::grpc::CompletionQueue* cq));\n"); *vars,
"MOCK_METHOD3($AsyncPrefix$$Method$Raw, "
"::grpc::ClientAsyncResponseReaderInterface< $Response$>*"
"(::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq));\n");
}
} else if (ClientOnlyStreaming(method)) { } else if (ClientOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
"MOCK_METHOD2($Method$Raw, " "MOCK_METHOD2($Method$Raw, "
"::grpc::ClientWriterInterface< $Request$>*" "::grpc::ClientWriterInterface< $Request$>*"
"(::grpc::ClientContext* context, $Response$* response));\n"); "(::grpc::ClientContext* context, $Response$* response));\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"MOCK_METHOD4(Async$Method$Raw, " auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncWriterInterface< $Request$>*" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"(::grpc::ClientContext* context, $Response$* response, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag));\n"); (*vars)["MockArgs"] =
flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);
printer->Print(*vars,
"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
"::grpc::ClientAsyncWriterInterface< $Request$>*"
"(::grpc::ClientContext* context, $Response$* response, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$));\n");
}
} else if (ServerOnlyStreaming(method)) { } else if (ServerOnlyStreaming(method)) {
printer->Print( printer->Print(
*vars, *vars,
"MOCK_METHOD2($Method$Raw, " "MOCK_METHOD2($Method$Raw, "
"::grpc::ClientReaderInterface< $Response$>*" "::grpc::ClientReaderInterface< $Response$>*"
"(::grpc::ClientContext* context, const $Request$& request));\n"); "(::grpc::ClientContext* context, const $Request$& request));\n");
printer->Print(*vars, for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
"MOCK_METHOD4(Async$Method$Raw, " auto& async_prefix = async_prefixes[i];
"::grpc::ClientAsyncReaderInterface< $Response$>*" (*vars)["AsyncPrefix"] = async_prefix.prefix;
"(::grpc::ClientContext* context, const $Request$& request, " (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"::grpc::CompletionQueue* cq, void* tag));\n"); (*vars)["MockArgs"] =
flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);
printer->Print(
*vars,
"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
"::grpc::ClientAsyncReaderInterface< $Response$>*"
"(::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq$AsyncMethodParams$));\n");
}
} else if (method->BidiStreaming()) { } else if (method->BidiStreaming()) {
printer->Print( printer->Print(
*vars, *vars,
"MOCK_METHOD1($Method$Raw, " "MOCK_METHOD1($Method$Raw, "
"::grpc::ClientReaderWriterInterface< $Request$, $Response$>*" "::grpc::ClientReaderWriterInterface< $Request$, $Response$>*"
"(::grpc::ClientContext* context));\n"); "(::grpc::ClientContext* context));\n");
printer->Print( for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
*vars, auto& async_prefix = async_prefixes[i];
"MOCK_METHOD3(Async$Method$Raw, " (*vars)["AsyncPrefix"] = async_prefix.prefix;
"::grpc::ClientAsyncReaderWriterInterface<$Request$, $Response$>*" (*vars)["AsyncMethodParams"] = async_prefix.method_params;
"(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, " (*vars)["MockArgs"] =
"void* tag));\n"); flatbuffers::NumToString(2 + async_prefix.extra_method_param_count);
printer->Print(
*vars,
"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
"::grpc::ClientAsyncReaderWriterInterface<$Request$, $Response$>*"
"(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq"
"$AsyncMethodParams$));\n");
}
} }
} }