aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/compiler
diff options
context:
space:
mode:
Diffstat (limited to 'src/compiler')
-rw-r--r--src/compiler/cpp_generator.cc478
-rw-r--r--src/compiler/csharp_generator.cc480
-rw-r--r--src/compiler/csharp_generator.h45
-rw-r--r--src/compiler/csharp_generator_helpers.h50
-rw-r--r--src/compiler/csharp_plugin.cc72
-rw-r--r--src/compiler/generator_helpers.h23
6 files changed, 1027 insertions, 121 deletions
diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc
index 4c20e9a24a..cfd7bf2b74 100644
--- a/src/compiler/cpp_generator.cc
+++ b/src/compiler/cpp_generator.cc
@@ -156,50 +156,16 @@ grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file,
"#include <grpc++/impl/internal_stub.h>\n"
"#include <grpc++/impl/rpc_method.h>\n"
"#include <grpc++/impl/service_type.h>\n"
+ "#include <grpc++/async_unary_call.h>\n"
"#include <grpc++/status.h>\n"
+ "#include <grpc++/stream.h>\n"
"\n"
"namespace grpc {\n"
"class CompletionQueue;\n"
"class ChannelInterface;\n"
"class RpcService;\n"
- "class ServerContext;\n";
- if (HasUnaryCalls(file)) {
- temp.append(
- "template <class OutMessage> class ClientAsyncResponseReader;\n");
- temp.append(
- "template <class OutMessage> class ServerAsyncResponseWriter;\n");
- }
- if (HasClientOnlyStreaming(file)) {
- temp.append("template <class OutMessage> class ClientWriter;\n");
- temp.append("template <class InMessage> class ServerReader;\n");
- temp.append("template <class OutMessage> class ClientAsyncWriter;\n");
- temp.append(
- "template <class OutMessage, class InMessage> class "
- "ServerAsyncReader;\n");
- }
- if (HasServerOnlyStreaming(file)) {
- temp.append("template <class InMessage> class ClientReader;\n");
- temp.append("template <class OutMessage> class ServerWriter;\n");
- temp.append("template <class OutMessage> class ClientAsyncReader;\n");
- temp.append("template <class InMessage> class ServerAsyncWriter;\n");
- }
- if (HasBidiStreaming(file)) {
- temp.append(
- "template <class OutMessage, class InMessage>\n"
- "class ClientReaderWriter;\n");
- temp.append(
- "template <class OutMessage, class InMessage>\n"
- "class ServerReaderWriter;\n");
- temp.append(
- "template <class OutMessage, class InMessage>\n"
- "class ClientAsyncReaderWriter;\n");
- temp.append(
- "template <class OutMessage, class InMessage>\n"
- "class ServerAsyncReaderWriter;\n");
- }
- temp.append("} // namespace grpc\n");
-
- temp.append("\n");
+ "class ServerContext;\n"
+ "} // namespace grpc\n\n";
if (!file->package().empty()) {
std::vector<grpc::string> parts =
@@ -216,54 +182,313 @@ grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file,
return temp;
}
+void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer,
+ const grpc::protobuf::MethodDescriptor *method,
+ std::map<grpc::string, grpc::string> *vars,
+ bool is_public) {
+ (*vars)["Method"] = method->name();
+ (*vars)["Request"] =
+ grpc_cpp_generator::ClassName(method->input_type(), true);
+ (*vars)["Response"] =
+ grpc_cpp_generator::ClassName(method->output_type(), true);
+
+ if (is_public) {
+ if (NoStreaming(method)) {
+ printer->Print(
+ *vars,
+ "virtual ::grpc::Status $Method$(::grpc::ClientContext* context, "
+ "const $Request$& request, $Response$* response) = 0;\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< "
+ "::grpc::ClientAsyncResponseReaderInterface< $Response$>> "
+ "Async$Method$(::grpc::ClientContext* context, "
+ "const $Request$& request, "
+ "::grpc::CompletionQueue* cq) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncResponseReaderInterface< $Response$>>("
+ "Async$Method$Raw(context, request, cq));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (ClientOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>"
+ " $Method$("
+ "::grpc::ClientContext* context, $Response$* response) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>"
+ "($Method$Raw(context, response));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>"
+ " Async$Method$(::grpc::ClientContext* context, $Response$* response, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncWriterInterface< $Request$>>("
+ "Async$Method$Raw(context, response, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (ServerOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>"
+ " $Method$(::grpc::ClientContext* context, const $Request$& request)"
+ " {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>"
+ "($Method$Raw(context, request));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncReaderInterface< $Response$>> "
+ "Async$Method$("
+ "::grpc::ClientContext* context, const $Request$& request, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncReaderInterface< $Response$>>("
+ "Async$Method$Raw(context, request, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (BidiStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientReaderWriterInterface< $Request$, $Response$>> "
+ "$Method$(::grpc::ClientContext* context) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientReaderWriterInterface< $Request$, $Response$>>("
+ "$Method$Raw(context));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< "
+ "::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>> "
+ "Async$Method$(::grpc::ClientContext* context, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>>("
+ "Async$Method$Raw(context, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ }
+ } else {
+ if (NoStreaming(method)) {
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* "
+ "Async$Method$Raw(::grpc::ClientContext* context, "
+ "const $Request$& request, "
+ "::grpc::CompletionQueue* cq) = 0;\n");
+ } else if (ClientOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientWriterInterface< $Request$>*"
+ " $Method$Raw("
+ "::grpc::ClientContext* context, $Response$* response) = 0;\n");
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientAsyncWriterInterface< $Request$>*"
+ " Async$Method$Raw(::grpc::ClientContext* context, "
+ "$Response$* response, "
+ "::grpc::CompletionQueue* cq, void* tag) = 0;\n");
+ } else if (ServerOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientReaderInterface< $Response$>* $Method$Raw("
+ "::grpc::ClientContext* context, const $Request$& request) = 0;\n");
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientAsyncReaderInterface< $Response$>* "
+ "Async$Method$Raw("
+ "::grpc::ClientContext* context, const $Request$& request, "
+ "::grpc::CompletionQueue* cq, void* tag) = 0;\n");
+ } else if (BidiStreaming(method)) {
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientReaderWriterInterface< $Request$, $Response$>* "
+ "$Method$Raw(::grpc::ClientContext* context) = 0;\n");
+ printer->Print(
+ *vars,
+ "virtual ::grpc::ClientAsyncReaderWriterInterface< "
+ "$Request$, $Response$>* "
+ "Async$Method$Raw(::grpc::ClientContext* context, "
+ "::grpc::CompletionQueue* cq, void* tag) = 0;\n");
+ }
+ }
+}
+
void PrintHeaderClientMethod(grpc::protobuf::io::Printer *printer,
const grpc::protobuf::MethodDescriptor *method,
- std::map<grpc::string, grpc::string> *vars) {
+ std::map<grpc::string, grpc::string> *vars,
+ bool is_public) {
(*vars)["Method"] = method->name();
(*vars)["Request"] =
grpc_cpp_generator::ClassName(method->input_type(), true);
(*vars)["Response"] =
grpc_cpp_generator::ClassName(method->output_type(), true);
- if (NoStreaming(method)) {
- printer->Print(*vars,
- "::grpc::Status $Method$(::grpc::ClientContext* context, "
- "const $Request$& request, $Response$* response);\n");
- printer->Print(
- *vars,
- "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
- "Async$Method$(::grpc::ClientContext* context, "
- "const $Request$& request, "
- "::grpc::CompletionQueue* cq);\n");
- } else if (ClientOnlyStreaming(method)) {
- printer->Print(
- *vars,
- "std::unique_ptr< ::grpc::ClientWriter< $Request$>> $Method$("
- "::grpc::ClientContext* context, $Response$* response);\n");
- printer->Print(
- *vars,
- "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>> Async$Method$("
- "::grpc::ClientContext* context, $Response$* response, "
- "::grpc::CompletionQueue* cq, void* tag);\n");
- } else if (ServerOnlyStreaming(method)) {
- printer->Print(
- *vars,
- "std::unique_ptr< ::grpc::ClientReader< $Response$>> $Method$("
- "::grpc::ClientContext* context, const $Request$& request);\n");
- printer->Print(*vars,
- "std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> "
- "Async$Method$("
- "::grpc::ClientContext* context, const $Request$& request, "
- "::grpc::CompletionQueue* cq, void* tag);\n");
- } else if (BidiStreaming(method)) {
- printer->Print(
- *vars,
- "std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>> "
- "$Method$(::grpc::ClientContext* context);\n");
- printer->Print(*vars,
- "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
- "$Request$, $Response$>> "
- "Async$Method$(::grpc::ClientContext* context, "
- "::grpc::CompletionQueue* cq, void* tag);\n");
+ if (is_public) {
+ if (NoStreaming(method)) {
+ printer->Print(
+ *vars,
+ "::grpc::Status $Method$(::grpc::ClientContext* context, "
+ "const $Request$& request, $Response$* response) GRPC_OVERRIDE;\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
+ "Async$Method$(::grpc::ClientContext* context, "
+ "const $Request$& request, "
+ "::grpc::CompletionQueue* cq) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncResponseReader< $Response$>>("
+ "Async$Method$Raw(context, request, cq));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (ClientOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientWriter< $Request$>>"
+ " $Method$("
+ "::grpc::ClientContext* context, $Response$* response) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientWriter< $Request$>>"
+ "($Method$Raw(context, response));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>"
+ " Async$Method$(::grpc::ClientContext* context, $Response$* response, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>("
+ "Async$Method$Raw(context, response, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (ServerOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientReader< $Response$>>"
+ " $Method$(::grpc::ClientContext* context, const $Request$& request)"
+ " {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientReader< $Response$>>"
+ "($Method$Raw(context, request));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> "
+ "Async$Method$("
+ "::grpc::ClientContext* context, const $Request$& request, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>>("
+ "Async$Method$Raw(context, request, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ } else if (BidiStreaming(method)) {
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>>"
+ " $Method$(::grpc::ClientContext* context) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientReaderWriter< $Request$, $Response$>>("
+ "$Method$Raw(context));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ printer->Print(
+ *vars,
+ "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
+ "$Request$, $Response$>> "
+ "Async$Method$(::grpc::ClientContext* context, "
+ "::grpc::CompletionQueue* cq, void* tag) {\n");
+ printer->Indent();
+ printer->Print(
+ *vars,
+ "return std::unique_ptr< "
+ "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>("
+ "Async$Method$Raw(context, cq, tag));\n");
+ printer->Outdent();
+ printer->Print("}\n");
+ }
+ } else {
+ if (NoStreaming(method)) {
+ printer->Print(
+ *vars,
+ "::grpc::ClientAsyncResponseReader< $Response$>* "
+ "Async$Method$Raw(::grpc::ClientContext* context, "
+ "const $Request$& request, "
+ "::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n");
+ } else if (ClientOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "::grpc::ClientWriter< $Request$>* $Method$Raw("
+ "::grpc::ClientContext* context, $Response$* response) "
+ "GRPC_OVERRIDE;\n");
+ printer->Print(
+ *vars,
+ "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw("
+ "::grpc::ClientContext* context, $Response$* response, "
+ "::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
+ } else if (ServerOnlyStreaming(method)) {
+ printer->Print(
+ *vars,
+ "::grpc::ClientReader< $Response$>* $Method$Raw("
+ "::grpc::ClientContext* context, const $Request$& request)"
+ " GRPC_OVERRIDE;\n");
+ printer->Print(
+ *vars,
+ "::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw("
+ "::grpc::ClientContext* context, const $Request$& request, "
+ "::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
+ } else if (BidiStreaming(method)) {
+ printer->Print(
+ *vars,
+ "::grpc::ClientReaderWriter< $Request$, $Response$>* "
+ "$Method$Raw(::grpc::ClientContext* context) GRPC_OVERRIDE;\n");
+ printer->Print(
+ *vars,
+ "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
+ "Async$Method$Raw(::grpc::ClientContext* context, "
+ "::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n");
+ }
}
}
@@ -357,18 +582,37 @@ void PrintHeaderService(grpc::protobuf::io::Printer *printer,
// Client side
printer->Print(
- "class Stub GRPC_FINAL : public ::grpc::InternalStub {\n"
+ "class StubInterface {\n"
" public:\n");
printer->Indent();
+ printer->Print("virtual ~StubInterface() {}\n");
+ for (int i = 0; i < service->method_count(); ++i) {
+ PrintHeaderClientMethodInterfaces(printer, service->method(i), vars, true);
+ }
+ printer->Outdent();
+ printer->Print("private:\n");
+ printer->Indent();
+ for (int i = 0; i < service->method_count(); ++i) {
+ PrintHeaderClientMethodInterfaces(printer, service->method(i), vars, false);
+ }
+ printer->Outdent();
+ printer->Print("};\n");
+ printer->Print(
+ "class Stub GRPC_FINAL : public StubInterface,"
+ " public ::grpc::InternalStub {\n public:\n");
+ printer->Indent();
printer->Print(
"Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);\n");
for (int i = 0; i < service->method_count(); ++i) {
- PrintHeaderClientMethod(printer, service->method(i), vars);
+ PrintHeaderClientMethod(printer, service->method(i), vars, true);
}
printer->Outdent();
- printer->Print(" private:\n");
+ printer->Print("\n private:\n");
printer->Indent();
for (int i = 0; i < service->method_count(); ++i) {
+ PrintHeaderClientMethod(printer, service->method(i), vars, false);
+ }
+ for (int i = 0; i < service->method_count(); ++i) {
PrintHeaderClientMethodData(printer, service->method(i), vars);
}
printer->Outdent();
@@ -535,93 +779,85 @@ void PrintSourceClientMethod(grpc::protobuf::io::Printer *printer,
"}\n\n");
printer->Print(
*vars,
- "std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> "
- "$ns$$Service$::Stub::Async$Method$(::grpc::ClientContext* context, "
+ "::grpc::ClientAsyncResponseReader< $Response$>* "
+ "$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, "
"const $Request$& request, "
"::grpc::CompletionQueue* cq) {\n");
printer->Print(*vars,
- " return std::unique_ptr< "
- "::grpc::ClientAsyncResponseReader< $Response$>>(new "
+ " return new "
"::grpc::ClientAsyncResponseReader< $Response$>("
"channel(), cq, "
"rpcmethod_$Method$_, "
- "context, request));\n"
+ "context, request);\n"
"}\n\n");
} else if (ClientOnlyStreaming(method)) {
printer->Print(*vars,
- "std::unique_ptr< ::grpc::ClientWriter< $Request$>> "
- "$ns$$Service$::Stub::$Method$("
+ "::grpc::ClientWriter< $Request$>* "
+ "$ns$$Service$::Stub::$Method$Raw("
"::grpc::ClientContext* context, $Response$* response) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientWriter< "
- "$Request$>>(new ::grpc::ClientWriter< $Request$>("
- "channel(),"
+ " return new ::grpc::ClientWriter< $Request$>("
+ "channel(), "
"rpcmethod_$Method$_, "
- "context, response));\n"
+ "context, response);\n"
"}\n\n");
printer->Print(*vars,
- "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>> "
- "$ns$$Service$::Stub::Async$Method$("
+ "::grpc::ClientAsyncWriter< $Request$>* "
+ "$ns$$Service$::Stub::Async$Method$Raw("
"::grpc::ClientContext* context, $Response$* response, "
"::grpc::CompletionQueue* cq, void* tag) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientAsyncWriter< "
- "$Request$>>(new ::grpc::ClientAsyncWriter< $Request$>("
+ " return new ::grpc::ClientAsyncWriter< $Request$>("
"channel(), cq, "
"rpcmethod_$Method$_, "
- "context, response, tag));\n"
+ "context, response, tag);\n"
"}\n\n");
} else if (ServerOnlyStreaming(method)) {
printer->Print(
*vars,
- "std::unique_ptr< ::grpc::ClientReader< $Response$>> "
- "$ns$$Service$::Stub::$Method$("
+ "::grpc::ClientReader< $Response$>* "
+ "$ns$$Service$::Stub::$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientReader< "
- "$Response$>>(new ::grpc::ClientReader< $Response$>("
- "channel(),"
+ " return new ::grpc::ClientReader< $Response$>("
+ "channel(), "
"rpcmethod_$Method$_, "
- "context, request));\n"
+ "context, request);\n"
"}\n\n");
printer->Print(*vars,
- "std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> "
- "$ns$$Service$::Stub::Async$Method$("
+ "::grpc::ClientAsyncReader< $Response$>* "
+ "$ns$$Service$::Stub::Async$Method$Raw("
"::grpc::ClientContext* context, const $Request$& request, "
"::grpc::CompletionQueue* cq, void* tag) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientAsyncReader< "
- "$Response$>>(new ::grpc::ClientAsyncReader< $Response$>("
+ " return new ::grpc::ClientAsyncReader< $Response$>("
"channel(), cq, "
"rpcmethod_$Method$_, "
- "context, request, tag));\n"
+ "context, request, tag);\n"
"}\n\n");
} else if (BidiStreaming(method)) {
printer->Print(
*vars,
- "std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>> "
- "$ns$$Service$::Stub::$Method$(::grpc::ClientContext* context) {\n");
+ "::grpc::ClientReaderWriter< $Request$, $Response$>* "
+ "$ns$$Service$::Stub::$Method$Raw(::grpc::ClientContext* context) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientReaderWriter< "
- "$Request$, $Response$>>(new ::grpc::ClientReaderWriter< "
+ " return new ::grpc::ClientReaderWriter< "
"$Request$, $Response$>("
- "channel(),"
+ "channel(), "
"rpcmethod_$Method$_, "
- "context));\n"
+ "context);\n"
"}\n\n");
printer->Print(
*vars,
- "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
- "$Request$, $Response$>> "
- "$ns$$Service$::Stub::Async$Method$(::grpc::ClientContext* context, "
+ "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
+ "$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, "
"::grpc::CompletionQueue* cq, void* tag) {\n");
printer->Print(*vars,
- " return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< "
- "$Request$, $Response$>>(new "
+ " return new "
"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>("
"channel(), cq, "
"rpcmethod_$Method$_, "
- "context, tag));\n"
+ "context, tag);\n"
"}\n\n");
}
}
diff --git a/src/compiler/csharp_generator.cc b/src/compiler/csharp_generator.cc
new file mode 100644
index 0000000000..82dd06bcec
--- /dev/null
+++ b/src/compiler/csharp_generator.cc
@@ -0,0 +1,480 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <cctype>
+#include <map>
+#include <vector>
+
+#include "src/compiler/config.h"
+#include "src/compiler/csharp_generator_helpers.h"
+#include "src/compiler/csharp_generator.h"
+
+using grpc::protobuf::FileDescriptor;
+using grpc::protobuf::Descriptor;
+using grpc::protobuf::ServiceDescriptor;
+using grpc::protobuf::MethodDescriptor;
+using grpc::protobuf::io::Printer;
+using grpc::protobuf::io::StringOutputStream;
+using grpc_generator::MethodType;
+using grpc_generator::GetMethodType;
+using grpc_generator::METHODTYPE_NO_STREAMING;
+using grpc_generator::METHODTYPE_CLIENT_STREAMING;
+using grpc_generator::METHODTYPE_SERVER_STREAMING;
+using grpc_generator::METHODTYPE_BIDI_STREAMING;
+using std::map;
+using std::vector;
+
+namespace grpc_csharp_generator {
+namespace {
+
+std::string GetCSharpNamespace(const FileDescriptor* file) {
+ // TODO(jtattermusch): this should be based on csharp_namespace option
+ return file->package();
+}
+
+std::string GetMessageType(const Descriptor* message) {
+ // TODO(jtattermusch): this has to match with C# protobuf generator
+ return message->name();
+}
+
+std::string GetServiceClassName(const ServiceDescriptor* service) {
+ return service->name();
+}
+
+std::string GetClientInterfaceName(const ServiceDescriptor* service) {
+ return "I" + service->name() + "Client";
+}
+
+std::string GetClientClassName(const ServiceDescriptor* service) {
+ return service->name() + "Client";
+}
+
+std::string GetServerInterfaceName(const ServiceDescriptor* service) {
+ return "I" + service->name();
+}
+
+std::string GetCSharpMethodType(MethodType method_type) {
+ switch (method_type) {
+ case METHODTYPE_NO_STREAMING:
+ return "MethodType.Unary";
+ case METHODTYPE_CLIENT_STREAMING:
+ return "MethodType.ClientStreaming";
+ case METHODTYPE_SERVER_STREAMING:
+ return "MethodType.ServerStreaming";
+ case METHODTYPE_BIDI_STREAMING:
+ return "MethodType.DuplexStreaming";
+ }
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ return "";
+}
+
+std::string GetServiceNameFieldName() {
+ return "__ServiceName";
+}
+
+std::string GetMarshallerFieldName(const Descriptor *message) {
+ return "__Marshaller_" + message->name();
+}
+
+std::string GetMethodFieldName(const MethodDescriptor *method) {
+ return "__Method_" + method->name();
+}
+
+std::string GetMethodRequestParamMaybe(const MethodDescriptor *method) {
+ if (method->client_streaming()) {
+ return "";
+ }
+ return GetMessageType(method->input_type()) + " request, ";
+}
+
+std::string GetMethodReturnTypeClient(const MethodDescriptor *method) {
+ switch (GetMethodType(method)) {
+ case METHODTYPE_NO_STREAMING:
+ return "Task<" + GetMessageType(method->output_type()) + ">";
+ case METHODTYPE_CLIENT_STREAMING:
+ return "AsyncClientStreamingCall<" + GetMessageType(method->input_type())
+ + ", " + GetMessageType(method->output_type()) + ">";
+ case METHODTYPE_SERVER_STREAMING:
+ return "AsyncServerStreamingCall<" + GetMessageType(method->output_type())
+ + ">";
+ case METHODTYPE_BIDI_STREAMING:
+ return "AsyncDuplexStreamingCall<" + GetMessageType(method->input_type())
+ + ", " + GetMessageType(method->output_type()) + ">";
+ }
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ return "";
+}
+
+std::string GetMethodRequestParamServer(const MethodDescriptor *method) {
+ switch (GetMethodType(method)) {
+ case METHODTYPE_NO_STREAMING:
+ case METHODTYPE_SERVER_STREAMING:
+ return GetMessageType(method->input_type()) + " request";
+ case METHODTYPE_CLIENT_STREAMING:
+ case METHODTYPE_BIDI_STREAMING:
+ return "IAsyncStreamReader<" + GetMessageType(method->input_type())
+ + "> requestStream";
+ }
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ return "";
+}
+
+std::string GetMethodReturnTypeServer(const MethodDescriptor *method) {
+ switch (GetMethodType(method)) {
+ case METHODTYPE_NO_STREAMING:
+ case METHODTYPE_CLIENT_STREAMING:
+ return "Task<" + GetMessageType(method->output_type()) + ">";
+ case METHODTYPE_SERVER_STREAMING:
+ case METHODTYPE_BIDI_STREAMING:
+ return "Task";
+ }
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ return "";
+}
+
+std::string GetMethodResponseStreamMaybe(const MethodDescriptor *method) {
+ switch (GetMethodType(method)) {
+ case METHODTYPE_NO_STREAMING:
+ case METHODTYPE_CLIENT_STREAMING:
+ return "";
+ case METHODTYPE_SERVER_STREAMING:
+ case METHODTYPE_BIDI_STREAMING:
+ return ", IServerStreamWriter<" + GetMessageType(method->output_type())
+ + "> responseStream";
+ }
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ return "";
+}
+
+// Gets vector of all messages used as input or output types.
+std::vector<const Descriptor*> GetUsedMessages(
+ const ServiceDescriptor *service) {
+ std::set<const Descriptor*> descriptor_set;
+ std::vector<const Descriptor*> result; // vector is to maintain stable ordering
+ for (int i = 0; i < service->method_count(); i++) {
+ const MethodDescriptor *method = service->method(i);
+ if (descriptor_set.find(method->input_type()) == descriptor_set.end()) {
+ descriptor_set.insert(method->input_type());
+ result.push_back(method->input_type());
+ }
+ if (descriptor_set.find(method->output_type()) == descriptor_set.end()) {
+ descriptor_set.insert(method->output_type());
+ result.push_back(method->output_type());
+ }
+ }
+ return result;
+}
+
+void GenerateMarshallerFields(Printer* out, const ServiceDescriptor *service) {
+ std::vector<const Descriptor*> used_messages = GetUsedMessages(service);
+ for (size_t i = 0; i < used_messages.size(); i++) {
+ const Descriptor *message = used_messages[i];
+ out->Print(
+ "static readonly Marshaller<$type$> $fieldname$ = Marshallers.Create((arg) => arg.ToByteArray(), $type$.ParseFrom);\n",
+ "fieldname", GetMarshallerFieldName(message), "type",
+ GetMessageType(message));
+ }
+ out->Print("\n");
+}
+
+void GenerateStaticMethodField(Printer* out, const MethodDescriptor *method) {
+ out->Print(
+ "static readonly Method<$request$, $response$> $fieldname$ = new Method<$request$, $response$>(\n",
+ "fieldname", GetMethodFieldName(method), "request",
+ GetMessageType(method->input_type()), "response",
+ GetMessageType(method->output_type()));
+ out->Indent();
+ out->Indent();
+ out->Print("$methodtype$,\n", "methodtype",
+ GetCSharpMethodType(GetMethodType(method)));
+ out->Print("\"$methodname$\",\n", "methodname", method->name());
+ out->Print("$requestmarshaller$,\n", "requestmarshaller",
+ GetMarshallerFieldName(method->input_type()));
+ out->Print("$responsemarshaller$);\n", "responsemarshaller",
+ GetMarshallerFieldName(method->output_type()));
+ out->Print("\n");
+ out->Outdent();
+ out->Outdent();
+}
+
+void GenerateClientInterface(Printer* out, const ServiceDescriptor *service) {
+ out->Print("// client-side stub interface\n");
+ out->Print("public interface $name$\n", "name",
+ GetClientInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+ for (int i = 0; i < service->method_count(); i++) {
+ const MethodDescriptor *method = service->method(i);
+ MethodType method_type = GetMethodType(method);
+
+ if (method_type == METHODTYPE_NO_STREAMING) {
+ // unary calls have an extra synchronous stub method
+ out->Print(
+ "$response$ $methodname$($request$ request, CancellationToken token = default(CancellationToken));\n",
+ "methodname", method->name(), "request",
+ GetMessageType(method->input_type()), "response",
+ GetMessageType(method->output_type()));
+ }
+
+ std::string method_name = method->name();
+ if (method_type == METHODTYPE_NO_STREAMING) {
+ method_name += "Async"; // prevent name clash with synchronous method.
+ }
+ out->Print(
+ "$returntype$ $methodname$($request_maybe$CancellationToken token = default(CancellationToken));\n",
+ "methodname", method_name, "request_maybe",
+ GetMethodRequestParamMaybe(method), "returntype",
+ GetMethodReturnTypeClient(method));
+ }
+ out->Outdent();
+ out->Print("}\n");
+ out->Print("\n");
+}
+
+void GenerateServerInterface(Printer* out, const ServiceDescriptor *service) {
+ out->Print("// server-side interface\n");
+ out->Print("public interface $name$\n", "name",
+ GetServerInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+ for (int i = 0; i < service->method_count(); i++) {
+ const MethodDescriptor *method = service->method(i);
+ out->Print("$returntype$ $methodname$(ServerCallContext context, $request$$response_stream_maybe$);\n",
+ "methodname", method->name(), "returntype",
+ GetMethodReturnTypeServer(method), "request",
+ GetMethodRequestParamServer(method), "response_stream_maybe",
+ GetMethodResponseStreamMaybe(method));
+ }
+ out->Outdent();
+ out->Print("}\n");
+ out->Print("\n");
+}
+
+void GenerateClientStub(Printer* out, const ServiceDescriptor *service) {
+ out->Print("// client stub\n");
+ out->Print(
+ "public class $name$ : AbstractStub<$name$, StubConfiguration>, $interface$\n",
+ "name", GetClientClassName(service), "interface",
+ GetClientInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+
+ // constructors
+ out->Print(
+ "public $name$(Channel channel) : this(channel, StubConfiguration.Default)\n",
+ "name", GetClientClassName(service));
+ out->Print("{\n");
+ out->Print("}\n");
+ out->Print(
+ "public $name$(Channel channel, StubConfiguration config) : base(channel, config)\n",
+ "name", GetClientClassName(service));
+ out->Print("{\n");
+ out->Print("}\n");
+
+ for (int i = 0; i < service->method_count(); i++) {
+ const MethodDescriptor *method = service->method(i);
+ MethodType method_type = GetMethodType(method);
+
+ if (method_type == METHODTYPE_NO_STREAMING) {
+ // unary calls have an extra synchronous stub method
+ out->Print(
+ "public $response$ $methodname$($request$ request, CancellationToken token = default(CancellationToken))\n",
+ "methodname", method->name(), "request",
+ GetMessageType(method->input_type()), "response",
+ GetMessageType(method->output_type()));
+ out->Print("{\n");
+ out->Indent();
+ out->Print("var call = CreateCall($servicenamefield$, $methodfield$);\n",
+ "servicenamefield", GetServiceNameFieldName(), "methodfield",
+ GetMethodFieldName(method));
+ out->Print("return Calls.BlockingUnaryCall(call, request, token);\n");
+ out->Outdent();
+ out->Print("}\n");
+ }
+
+ std::string method_name = method->name();
+ if (method_type == METHODTYPE_NO_STREAMING) {
+ method_name += "Async"; // prevent name clash with synchronous method.
+ }
+ out->Print(
+ "public $returntype$ $methodname$($request_maybe$CancellationToken token = default(CancellationToken))\n",
+ "methodname", method_name, "request_maybe",
+ GetMethodRequestParamMaybe(method), "returntype",
+ GetMethodReturnTypeClient(method));
+ out->Print("{\n");
+ out->Indent();
+ out->Print("var call = CreateCall($servicenamefield$, $methodfield$);\n",
+ "servicenamefield", GetServiceNameFieldName(), "methodfield",
+ GetMethodFieldName(method));
+ switch (GetMethodType(method)) {
+ case METHODTYPE_NO_STREAMING:
+ out->Print("return Calls.AsyncUnaryCall(call, request, token);\n");
+ break;
+ case METHODTYPE_CLIENT_STREAMING:
+ out->Print("return Calls.AsyncClientStreamingCall(call, token);\n");
+ break;
+ case METHODTYPE_SERVER_STREAMING:
+ out->Print(
+ "return Calls.AsyncServerStreamingCall(call, request, token);\n");
+ break;
+ case METHODTYPE_BIDI_STREAMING:
+ out->Print("return Calls.AsyncDuplexStreamingCall(call, token);\n");
+ break;
+ default:
+ GOOGLE_LOG(FATAL)<< "Can't get here.";
+ }
+ out->Outdent();
+ out->Print("}\n");
+ }
+ out->Outdent();
+ out->Print("}\n");
+ out->Print("\n");
+}
+
+void GenerateBindServiceMethod(Printer* out, const ServiceDescriptor *service) {
+ out->Print(
+ "// creates service definition that can be registered with a server\n");
+ out->Print(
+ "public static ServerServiceDefinition BindService($interface$ serviceImpl)\n",
+ "interface", GetServerInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+
+ out->Print(
+ "return ServerServiceDefinition.CreateBuilder($servicenamefield$)\n",
+ "servicenamefield", GetServiceNameFieldName());
+ out->Indent();
+ out->Indent();
+ for (int i = 0; i < service->method_count(); i++) {
+ const MethodDescriptor *method = service->method(i);
+ out->Print(".AddMethod($methodfield$, serviceImpl.$methodname$)",
+ "methodfield", GetMethodFieldName(method), "methodname",
+ method->name());
+ if (i == service->method_count() - 1) {
+ out->Print(".Build();");
+ }
+ out->Print("\n");
+ }
+ out->Outdent();
+ out->Outdent();
+
+ out->Outdent();
+ out->Print("}\n");
+ out->Print("\n");
+}
+
+void GenerateNewStubMethods(Printer* out, const ServiceDescriptor *service) {
+ out->Print("// creates a new client stub\n");
+ out->Print("public static $interface$ NewStub(Channel channel)\n",
+ "interface", GetClientInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+ out->Print("return new $classname$(channel);\n", "classname",
+ GetClientClassName(service));
+ out->Outdent();
+ out->Print("}\n");
+ out->Print("\n");
+
+ out->Print("// creates a new client stub\n");
+ out->Print(
+ "public static $interface$ NewStub(Channel channel, StubConfiguration config)\n",
+ "interface", GetClientInterfaceName(service));
+ out->Print("{\n");
+ out->Indent();
+ out->Print("return new $classname$(channel, config);\n", "classname",
+ GetClientClassName(service));
+ out->Outdent();
+ out->Print("}\n");
+}
+
+void GenerateService(Printer* out, const ServiceDescriptor *service) {
+ out->Print("public static class $classname$\n", "classname",
+ GetServiceClassName(service));
+ out->Print("{\n");
+ out->Indent();
+ out->Print("static readonly string $servicenamefield$ = \"$servicename$\";\n",
+ "servicenamefield", GetServiceNameFieldName(), "servicename",
+ service->full_name());
+ out->Print("\n");
+
+ GenerateMarshallerFields(out, service);
+ for (int i = 0; i < service->method_count(); i++) {
+ GenerateStaticMethodField(out, service->method(i));
+ }
+ GenerateClientInterface(out, service);
+ GenerateServerInterface(out, service);
+ GenerateClientStub(out, service);
+ GenerateBindServiceMethod(out, service);
+ GenerateNewStubMethods(out, service);
+
+ out->Outdent();
+ out->Print("}\n");
+}
+
+} // anonymous namespace
+
+grpc::string GetServices(const FileDescriptor *file) {
+ grpc::string output;
+ StringOutputStream output_stream(&output);
+ Printer out(&output_stream, '$');
+
+ // Don't write out any output if there no services, to avoid empty service
+ // files being generated for proto files that don't declare any.
+ if (file->service_count() == 0) {
+ return output;
+ }
+
+ // Write out a file header.
+ out.Print("// Generated by the protocol buffer compiler. DO NOT EDIT!\n");
+ out.Print("// source: $filename$\n", "filename", file->name());
+ out.Print("#region Designer generated code\n");
+ out.Print("\n");
+ out.Print("using System;\n");
+ out.Print("using System.Threading;\n");
+ out.Print("using System.Threading.Tasks;\n");
+ out.Print("using Grpc.Core;\n");
+ // TODO(jtattermusch): add using for protobuf message classes
+ out.Print("\n");
+
+ out.Print("namespace $namespace$ {\n", "namespace", GetCSharpNamespace(file));
+ out.Indent();
+ for (int i = 0; i < file->service_count(); i++) {
+ GenerateService(&out, file->service(i));
+ }
+ out.Outdent();
+ out.Print("}\n");
+ out.Print("#endregion\n");
+ return output;
+}
+
+} // namespace grpc_csharp_generator
diff --git a/src/compiler/csharp_generator.h b/src/compiler/csharp_generator.h
new file mode 100644
index 0000000000..ec537d3f1d
--- /dev/null
+++ b/src/compiler/csharp_generator.h
@@ -0,0 +1,45 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_H
+#define GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_H
+
+#include "src/compiler/config.h"
+
+namespace grpc_csharp_generator {
+
+grpc::string GetServices(const grpc::protobuf::FileDescriptor *file);
+
+} // namespace grpc_csharp_generator
+
+#endif // GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_H
diff --git a/src/compiler/csharp_generator_helpers.h b/src/compiler/csharp_generator_helpers.h
new file mode 100644
index 0000000000..1370627633
--- /dev/null
+++ b/src/compiler/csharp_generator_helpers.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_HELPERS_H
+#define GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_HELPERS_H
+
+#include "src/compiler/config.h"
+#include "src/compiler/generator_helpers.h"
+
+namespace grpc_csharp_generator {
+
+inline bool ServicesFilename(const grpc::protobuf::FileDescriptor *file,
+ grpc::string *file_name_or_error) {
+ *file_name_or_error = grpc_generator::FileNameInUpperCamel(file) + "Grpc.cs";
+ return true;
+}
+
+} // namespace grpc_csharp_generator
+
+#endif // GRPC_INTERNAL_COMPILER_CSHARP_GENERATOR_HELPERS_H
diff --git a/src/compiler/csharp_plugin.cc b/src/compiler/csharp_plugin.cc
new file mode 100644
index 0000000000..8b9395f9e2
--- /dev/null
+++ b/src/compiler/csharp_plugin.cc
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+// Generates C# gRPC service interface out of Protobuf IDL.
+
+#include <memory>
+
+#include "src/compiler/config.h"
+#include "src/compiler/csharp_generator.h"
+#include "src/compiler/csharp_generator_helpers.h"
+
+class CSharpGrpcGenerator : public grpc::protobuf::compiler::CodeGenerator {
+ public:
+ CSharpGrpcGenerator() {}
+ ~CSharpGrpcGenerator() {}
+
+ bool Generate(const grpc::protobuf::FileDescriptor *file,
+ const grpc::string &parameter,
+ grpc::protobuf::compiler::GeneratorContext *context,
+ grpc::string *error) const {
+ grpc::string code = grpc_csharp_generator::GetServices(file);
+ if (code.size() == 0) {
+ return true; // don't generate a file if there are no services
+ }
+
+ // Get output file name.
+ grpc::string file_name;
+ if (!grpc_csharp_generator::ServicesFilename(file, &file_name)) {
+ return false;
+ }
+ std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> output(
+ context->Open(file_name));
+ grpc::protobuf::io::CodedOutputStream coded_out(output.get());
+ coded_out.WriteRaw(code.data(), code.size());
+ return true;
+ }
+};
+
+int main(int argc, char *argv[]) {
+ CSharpGrpcGenerator generator;
+ return grpc::protobuf::compiler::PluginMain(argc, argv, &generator);
+}
diff --git a/src/compiler/generator_helpers.h b/src/compiler/generator_helpers.h
index 374e1374cf..7ce4ec526c 100644
--- a/src/compiler/generator_helpers.h
+++ b/src/compiler/generator_helpers.h
@@ -116,6 +116,29 @@ inline grpc::string FileNameInUpperCamel(const grpc::protobuf::FileDescriptor *f
return LowerUnderscoreToUpperCamel(StripProto(file->name()));
}
+enum MethodType {
+ METHODTYPE_NO_STREAMING,
+ METHODTYPE_CLIENT_STREAMING,
+ METHODTYPE_SERVER_STREAMING,
+ METHODTYPE_BIDI_STREAMING
+};
+
+inline MethodType GetMethodType(const grpc::protobuf::MethodDescriptor *method) {
+ if (method->client_streaming()) {
+ if (method->server_streaming()) {
+ return METHODTYPE_BIDI_STREAMING;
+ } else {
+ return METHODTYPE_CLIENT_STREAMING;
+ }
+ } else {
+ if (method->server_streaming()) {
+ return METHODTYPE_SERVER_STREAMING;
+ } else {
+ return METHODTYPE_NO_STREAMING;
+ }
+ }
+}
+
} // namespace grpc_generator
#endif // GRPC_INTERNAL_COMPILER_GENERATOR_HELPERS_H
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-08 07:24:11 +0000