| /* |
| * |
| * 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 grpc_generator::StringReplace; |
| using std::map; |
| using std::vector; |
| |
| namespace grpc_csharp_generator { |
| namespace { |
| |
| // TODO(jtattermusch): make GetFileNamespace part of libprotoc public API. |
| // NOTE: Implementation needs to match exactly to GetFileNamespace |
| // defined in csharp_helpers.h in protoc csharp plugin. |
| // We cannot reference it directly because google3 protobufs |
| // don't have a csharp protoc plugin. |
| std::string GetFileNamespace(const FileDescriptor* file) { |
| if (file->options().has_csharp_namespace()) { |
| return file->options().csharp_namespace(); |
| } |
| return file->package(); |
| } |
| |
| std::string ToCSharpName(const std::string& name, const FileDescriptor* file) { |
| std::string result = GetFileNamespace(file); |
| if (result != "") { |
| result += '.'; |
| } |
| std::string classname; |
| if (file->package().empty()) { |
| classname = name; |
| } else { |
| // Strip the proto package from full_name since we've replaced it with |
| // the C# namespace. |
| classname = name.substr(file->package().size() + 1); |
| } |
| result += StringReplace(classname, ".", ".Types.", false); |
| return "global::" + result; |
| } |
| |
| // TODO(jtattermusch): make GetClassName part of libprotoc public API. |
| // NOTE: Implementation needs to match exactly to GetClassName |
| // defined in csharp_helpers.h in protoc csharp plugin. |
| // We cannot reference it directly because google3 protobufs |
| // don't have a csharp protoc plugin. |
| std::string GetClassName(const Descriptor* message) { |
| return ToCSharpName(message->full_name(), message->file()); |
| } |
| |
| 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 GetClassName(method->input_type()) + " request, "; |
| } |
| |
| std::string GetMethodReturnTypeClient(const MethodDescriptor *method) { |
| switch (GetMethodType(method)) { |
| case METHODTYPE_NO_STREAMING: |
| return "AsyncUnaryCall<" + GetClassName(method->output_type()) + ">"; |
| case METHODTYPE_CLIENT_STREAMING: |
| return "AsyncClientStreamingCall<" + GetClassName(method->input_type()) |
| + ", " + GetClassName(method->output_type()) + ">"; |
| case METHODTYPE_SERVER_STREAMING: |
| return "AsyncServerStreamingCall<" + GetClassName(method->output_type()) |
| + ">"; |
| case METHODTYPE_BIDI_STREAMING: |
| return "AsyncDuplexStreamingCall<" + GetClassName(method->input_type()) |
| + ", " + GetClassName(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 GetClassName(method->input_type()) + " request"; |
| case METHODTYPE_CLIENT_STREAMING: |
| case METHODTYPE_BIDI_STREAMING: |
| return "IAsyncStreamReader<" + GetClassName(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<" + GetClassName(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<" + GetClassName(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", |
| GetClassName(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", |
| GetClassName(method->input_type()), "response", |
| GetClassName(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 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, Metadata headers = null, CancellationToken cancellationToken = default(CancellationToken));\n", |
| "methodname", method->name(), "request", |
| GetClassName(method->input_type()), "response", |
| GetClassName(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$Metadata headers = null, CancellationToken cancellationToken = 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$($request$$response_stream_maybe$, ServerCallContext context);\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$ : ClientBase, $interface$\n", |
| "name", GetClientClassName(service), "interface", |
| GetClientInterfaceName(service)); |
| out->Print("{\n"); |
| out->Indent(); |
| |
| // constructors |
| out->Print( |
| "public $name$(Channel channel) : base(channel)\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, Metadata headers = null, CancellationToken cancellationToken = default(CancellationToken))\n", |
| "methodname", method->name(), "request", |
| GetClassName(method->input_type()), "response", |
| GetClassName(method->output_type())); |
| out->Print("{\n"); |
| out->Indent(); |
| out->Print("var call = CreateCall($servicenamefield$, $methodfield$, headers);\n", |
| "servicenamefield", GetServiceNameFieldName(), "methodfield", |
| GetMethodFieldName(method)); |
| out->Print("return Calls.BlockingUnaryCall(call, request, cancellationToken);\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$Metadata headers = null, CancellationToken cancellationToken = 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$, headers);\n", |
| "servicenamefield", GetServiceNameFieldName(), "methodfield", |
| GetMethodFieldName(method)); |
| switch (GetMethodType(method)) { |
| case METHODTYPE_NO_STREAMING: |
| out->Print("return Calls.AsyncUnaryCall(call, request, cancellationToken);\n"); |
| break; |
| case METHODTYPE_CLIENT_STREAMING: |
| out->Print("return Calls.AsyncClientStreamingCall(call, cancellationToken);\n"); |
| break; |
| case METHODTYPE_SERVER_STREAMING: |
| out->Print( |
| "return Calls.AsyncServerStreamingCall(call, request, cancellationToken);\n"); |
| break; |
| case METHODTYPE_BIDI_STREAMING: |
| out->Print("return Calls.AsyncDuplexStreamingCall(call, cancellationToken);\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\n"); |
| out->Print("public static $classname$ NewClient(Channel channel)\n", |
| "classname", GetClientClassName(service)); |
| out->Print("{\n"); |
| out->Indent(); |
| out->Print("return new $classname$(channel);\n", "classname", |
| GetClientClassName(service)); |
| out->Outdent(); |
| out->Print("}\n"); |
| 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; |
| { |
| // Scope the output stream so it closes and finalizes output to the string. |
| |
| 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", GetFileNamespace(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 |