mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-06 13:37:25 +00:00
537212afee
* Formats files & adds licence * Revert arrays * Keeps array indentation as is * Adds licence to code formatter * Updates code generators
317 lines
12 KiB
C++
317 lines
12 KiB
C++
/*
|
|
* Copyright 2020 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* NOTE: The following implementation is a translation for the Swift-grpc
|
|
* generator since flatbuffers doesnt allow plugins for now. if an issue arises
|
|
* please open an issue in the flatbuffers repository. This file should always
|
|
* be maintained according to the Swift-grpc repository
|
|
*/
|
|
#include <map>
|
|
#include <sstream>
|
|
|
|
#include "flatbuffers/util.h"
|
|
#include "src/compiler/schema_interface.h"
|
|
#include "src/compiler/swift_generator.h"
|
|
|
|
namespace grpc_swift_generator {
|
|
|
|
std::string WrapInNameSpace(const std::vector<std::string> &components, const grpc::string &name) {
|
|
std::string qualified_name;
|
|
for (auto it = components.begin(); it != components.end(); ++it)
|
|
qualified_name += *it + "_";
|
|
return qualified_name + name;
|
|
}
|
|
|
|
grpc::string GenerateMessage(const std::vector<std::string> &components, const grpc::string &name) {
|
|
return "Message<" + WrapInNameSpace(components, name) + ">";
|
|
}
|
|
|
|
// MARK: - Client
|
|
|
|
grpc::string GenerateClientFuncName(const grpc_generator::Method *method) {
|
|
if (method->NoStreaming()) {
|
|
return "$GenAccess$ func $MethodName$(_ request: $Input$"
|
|
", callOptions: CallOptions?$isNil$) -> UnaryCall<$Input$,$Output$>";
|
|
}
|
|
|
|
if (method->ClientStreaming()) {
|
|
return "$GenAccess$ func $MethodName$"
|
|
"(callOptions: CallOptions?$isNil$) -> "
|
|
"ClientStreamingCall<$Input$,$Output$>";
|
|
}
|
|
|
|
if (method->ServerStreaming()) {
|
|
return "$GenAccess$ func $MethodName$(_ request: $Input$"
|
|
", callOptions: CallOptions?$isNil$, handler: @escaping ($Output$"
|
|
") -> Void) -> ServerStreamingCall<$Input$, $Output$>";
|
|
}
|
|
return "$GenAccess$ func $MethodName$"
|
|
"(callOptions: CallOptions?$isNil$, handler: @escaping ($Output$"
|
|
") -> Void) -> BidirectionalStreamingCall<$Input$, $Output$>";
|
|
}
|
|
|
|
grpc::string GenerateClientFuncBody(const grpc_generator::Method *method) {
|
|
if (method->NoStreaming()) {
|
|
return "return self.makeUnaryCall(path: "
|
|
"\"/$PATH$$ServiceName$/$MethodName$\", request: request, "
|
|
"callOptions: callOptions ?? self.defaultCallOptions)";
|
|
}
|
|
|
|
if (method->ClientStreaming()) {
|
|
return "return self.makeClientStreamingCall(path: "
|
|
"\"/$PATH$$ServiceName$/$MethodName$\", callOptions: callOptions ?? "
|
|
"self.defaultCallOptions)";
|
|
}
|
|
|
|
if (method->ServerStreaming()) {
|
|
return "return self.makeServerStreamingCall(path: "
|
|
"\"/$PATH$$ServiceName$/$MethodName$\", request: request, "
|
|
"callOptions: callOptions ?? self.defaultCallOptions, handler: "
|
|
"handler)";
|
|
}
|
|
return "return self.makeBidirectionalStreamingCall(path: "
|
|
"\"/$PATH$$ServiceName$/$MethodName$\", callOptions: callOptions ?? "
|
|
"self.defaultCallOptions, handler: handler)";
|
|
}
|
|
|
|
void GenerateClientProtocol(const grpc_generator::Service *service,
|
|
grpc_generator::Printer *printer,
|
|
std::map<grpc::string, grpc::string> *dictonary) {
|
|
auto vars = *dictonary;
|
|
printer->Print(vars, "$ACCESS$ protocol $ServiceQualifiedName$Service {\n");
|
|
vars["GenAccess"] = "";
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
vars["isNil"] = "";
|
|
printer->Print(" ");
|
|
auto func = GenerateClientFuncName(method.get());
|
|
printer->Print(vars, func.c_str());
|
|
printer->Print("\n");
|
|
}
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
void GenerateClientClass(const grpc_generator::Service *service,
|
|
grpc_generator::Printer *printer,
|
|
std::map<grpc::string, grpc::string> *dictonary) {
|
|
auto vars = *dictonary;
|
|
printer->Print(vars,
|
|
"$ACCESS$ final class $ServiceQualifiedName$ServiceClient: GRPCClient, "
|
|
"$ServiceQualifiedName$Service {\n");
|
|
printer->Print(vars, " $ACCESS$ let channel: GRPCChannel\n");
|
|
printer->Print(vars, " $ACCESS$ var defaultCallOptions: CallOptions\n");
|
|
printer->Print("\n");
|
|
printer->Print(vars,
|
|
" $ACCESS$ init(channel: GRPCChannel, "
|
|
"defaultCallOptions: CallOptions = CallOptions()) {\n");
|
|
printer->Print(" self.channel = channel\n");
|
|
printer->Print(" self.defaultCallOptions = defaultCallOptions\n");
|
|
printer->Print(" }");
|
|
printer->Print("\n");
|
|
vars["GenAccess"] = service->is_internal() ? "internal" : "public";
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
vars["isNil"] = " = nil";
|
|
printer->Print("\n ");
|
|
auto func = GenerateClientFuncName(method.get());
|
|
printer->Print(vars, func.c_str());
|
|
printer->Print(" {\n");
|
|
auto body = GenerateClientFuncBody(method.get());
|
|
printer->Print(" ");
|
|
printer->Print(vars, body.c_str());
|
|
printer->Print("\n }\n");
|
|
}
|
|
printer->Print("}\n");
|
|
}
|
|
|
|
// MARK: - Server
|
|
|
|
grpc::string GenerateServerFuncName(const grpc_generator::Method *method) {
|
|
if (method->NoStreaming()) {
|
|
return "func $MethodName$(_ request: $Input$"
|
|
", context: StatusOnlyCallContext) -> EventLoopFuture<$Output$>";
|
|
}
|
|
|
|
if (method->ClientStreaming()) {
|
|
return "func $MethodName$(context: UnaryResponseCallContext<$Output$>) -> "
|
|
"EventLoopFuture<(StreamEvent<$Input$"
|
|
">) -> Void>";
|
|
}
|
|
|
|
if (method->ServerStreaming()) {
|
|
return "func $MethodName$(request: $Input$"
|
|
", context: StreamingResponseCallContext<$Output$>) -> "
|
|
"EventLoopFuture<GRPCStatus>";
|
|
}
|
|
return "func $MethodName$(context: StreamingResponseCallContext<$Output$>) "
|
|
"-> EventLoopFuture<(StreamEvent<$Input$>) -> Void>";
|
|
}
|
|
|
|
grpc::string GenerateServerExtensionBody(const grpc_generator::Method *method) {
|
|
grpc::string start = " case \"$MethodName$\":\n ";
|
|
if (method->NoStreaming()) {
|
|
return start +
|
|
"return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { "
|
|
"context in"
|
|
"\n "
|
|
"return { request in"
|
|
"\n "
|
|
"self.$MethodName$(request, context: context)"
|
|
"\n }"
|
|
"\n }";
|
|
}
|
|
if (method->ClientStreaming()) {
|
|
return start +
|
|
"return CallHandlerFactory.makeClientStreaming(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n "
|
|
"self.$MethodName$(context: context)"
|
|
"\n }";
|
|
}
|
|
if (method->ServerStreaming()) {
|
|
return start +
|
|
"return CallHandlerFactory.makeServerStreaming(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n "
|
|
"return { request in"
|
|
"\n "
|
|
"self.$MethodName$(request: request, context: context)"
|
|
"\n }"
|
|
"\n }";
|
|
}
|
|
if (method->BidiStreaming()) {
|
|
return start +
|
|
"return CallHandlerFactory.makeBidirectionalStreaming(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n "
|
|
"self.$MethodName$(context: context)"
|
|
"\n }";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void GenerateServerProtocol(const grpc_generator::Service *service,
|
|
grpc_generator::Printer *printer,
|
|
std::map<grpc::string, grpc::string> *dictonary) {
|
|
auto vars = *dictonary;
|
|
printer->Print(
|
|
vars, "$ACCESS$ protocol $ServiceQualifiedName$Provider: CallHandlerProvider {\n");
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
printer->Print(" ");
|
|
auto func = GenerateServerFuncName(method.get());
|
|
printer->Print(vars, func.c_str());
|
|
printer->Print("\n");
|
|
}
|
|
printer->Print("}\n\n");
|
|
|
|
printer->Print(vars, "$ACCESS$ extension $ServiceQualifiedName$Provider {\n");
|
|
printer->Print("\n");
|
|
printer->Print(vars,
|
|
" var serviceName: Substring { return "
|
|
"\"$PATH$$ServiceName$\" }\n");
|
|
printer->Print("\n");
|
|
printer->Print(
|
|
" func handleMethod(_ methodName: Substring, callHandlerContext: "
|
|
"CallHandlerContext) -> GRPCCallHandler? {\n");
|
|
printer->Print(" switch methodName {\n");
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
auto body = GenerateServerExtensionBody(method.get());
|
|
printer->Print(vars, body.c_str());
|
|
printer->Print("\n");
|
|
}
|
|
printer->Print(" default: return nil;\n");
|
|
printer->Print(" }\n");
|
|
printer->Print(" }\n\n");
|
|
printer->Print("}");
|
|
}
|
|
|
|
grpc::string Generate(grpc_generator::File *file,
|
|
const grpc_generator::Service *service) {
|
|
grpc::string output;
|
|
std::map<grpc::string, grpc::string> vars;
|
|
vars["PATH"] = file->package();
|
|
if (!file->package().empty()) { vars["PATH"].append("."); }
|
|
vars["ServiceQualifiedName"] = WrapInNameSpace(service->namespace_parts(), service->name());
|
|
vars["ServiceName"] = service->name();
|
|
vars["ACCESS"] = service->is_internal() ? "internal" : "public";
|
|
auto printer = file->CreatePrinter(&output);
|
|
printer->Print(vars,
|
|
"/// Usage: instantiate $ServiceQualifiedName$ServiceClient, then call "
|
|
"methods of this protocol to make API calls.\n");
|
|
GenerateClientProtocol(service, &*printer, &vars);
|
|
GenerateClientClass(service, &*printer, &vars);
|
|
printer->Print("\n");
|
|
GenerateServerProtocol(service, &*printer, &vars);
|
|
return output;
|
|
}
|
|
|
|
grpc::string GenerateHeader() {
|
|
grpc::string code;
|
|
code +=
|
|
"/// The following code is generated by the Flatbuffers library which "
|
|
"might not be in sync with grpc-swift\n";
|
|
code +=
|
|
"/// in case of an issue please open github issue, though it would be "
|
|
"maintained\n";
|
|
code += "\n";
|
|
code += "// swiftlint:disable all\n";
|
|
code += "// swiftformat:disable all\n";
|
|
code += "\n";
|
|
code += "import Foundation\n";
|
|
code += "import GRPC\n";
|
|
code += "import NIO\n";
|
|
code += "import NIOHTTP1\n";
|
|
code += "import FlatBuffers\n";
|
|
code += "\n";
|
|
code +=
|
|
"public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage "
|
|
"{}\n";
|
|
|
|
code += "public extension GRPCFlatBufPayload {\n";
|
|
code += " init(serializedByteBuffer: inout NIO.ByteBuffer) throws {\n";
|
|
code +=
|
|
" self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: "
|
|
"serializedByteBuffer.readableBytesView, count: "
|
|
"serializedByteBuffer.readableBytes))\n";
|
|
code += " }\n";
|
|
|
|
code += " func serialize(into buffer: inout NIO.ByteBuffer) throws {\n";
|
|
code +=
|
|
" let buf = UnsafeRawBufferPointer(start: self.rawPointer, count: "
|
|
"Int(self.size))\n";
|
|
code += " buffer.writeBytes(buf)\n";
|
|
code += " }\n";
|
|
code += "}\n";
|
|
code += "extension Message: GRPCFlatBufPayload {}\n";
|
|
return code;
|
|
}
|
|
} // namespace grpc_swift_generator
|