mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-06 13:37:25 +00:00
34305c4ce4
* Adds the basic structure for required to add grpc support Added the message implementation Updated the code to confirm to the protocol flatbuffersobject Adds an example for Swift flatbuffers GRPC Started implementing the swift GRPC code Gen Generator generates protocols now Fixing ci issues Migrated the logic to use grpc_generator::File instead of string Refactored swift project Implemented GRPC in swift Finished implementing GRPC in swift Fixes issues Adds contiguousBytes initializer to swift Adds documentation + fixes buffer nameing in tables + structs Adds documentation + fixes buffer nameing in tables + structs Updated tests * Updated version
309 lines
11 KiB
C++
309 lines
11 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 {
|
|
|
|
grpc::string GenerateMessage(const grpc::string &name) {
|
|
return "Message<" + 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 $ServiceName$Service {\n");
|
|
vars["GenAccess"] = "";
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
vars["isNil"] = "";
|
|
printer->Print("\t");
|
|
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 $ServiceName$ServiceClient: GRPCClient, "
|
|
"$ServiceName$Service {\n");
|
|
printer->Print(vars, "\t$ACCESS$ let connection: ClientConnection\n");
|
|
printer->Print(vars, "\t$ACCESS$ var defaultCallOptions: CallOptions\n");
|
|
printer->Print("\n");
|
|
printer->Print(vars,
|
|
"\t$ACCESS$ init(connection: ClientConnection, "
|
|
"defaultCallOptions: CallOptions = CallOptions()) {\n");
|
|
printer->Print("\t\tself.connection = connection\n");
|
|
printer->Print("\t\tself.defaultCallOptions = defaultCallOptions\n");
|
|
printer->Print("\t}");
|
|
printer->Print("\n");
|
|
vars["GenAccess"] = "public";
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
vars["isNil"] = " = nil";
|
|
printer->Print("\n\t");
|
|
auto func = GenerateClientFuncName(method.get());
|
|
printer->Print(vars, func.c_str());
|
|
printer->Print(" {\n");
|
|
auto body = GenerateClientFuncBody(method.get());
|
|
printer->Print("\t\t");
|
|
printer->Print(vars, body.c_str());
|
|
printer->Print("\n\t}\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 = "\t\tcase \"$MethodName$\":\n\t\t";
|
|
if (method->NoStreaming()) {
|
|
return start +
|
|
"return UnaryCallHandler(callHandlerContext: callHandlerContext) { "
|
|
"context in"
|
|
"\n\t\t\t"
|
|
"return { request in"
|
|
"\n\t\t\t\t"
|
|
"self.$MethodName$(request, context: context)"
|
|
"\n\t\t\t}"
|
|
"\n\t\t}";
|
|
}
|
|
if (method->ClientStreaming()) {
|
|
return start +
|
|
"return ClientStreamingCallHandler(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n\t\t\t"
|
|
"return { request in"
|
|
"\n\t\t\t\t"
|
|
"self.$MethodName$(request: request, context: context)"
|
|
"\n\t\t\t}"
|
|
"\n\t\t}";
|
|
}
|
|
if (method->ServerStreaming()) {
|
|
return start +
|
|
"return ServerStreamingCallHandler(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n\t\t\t"
|
|
"return { request in"
|
|
"\n\t\t\t\t"
|
|
"self.$MethodName$(request: request, context: context)"
|
|
"\n\t\t\t}"
|
|
"\n\t\t}";
|
|
}
|
|
if (method->BidiStreaming()) {
|
|
return start +
|
|
"return BidirectionalStreamingCallHandler(callHandlerContext: "
|
|
"callHandlerContext) { context in"
|
|
"\n\t\t\t"
|
|
"return { request in"
|
|
"\n\t\t\t\t"
|
|
"self.$MethodName$(request: request, context: context)"
|
|
"\n\t\t\t}"
|
|
"\n\t\t}";
|
|
}
|
|
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 $ServiceName$Provider: CallHandlerProvider {\n");
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(method->get_output_type_name());
|
|
vars["MethodName"] = method->name();
|
|
printer->Print("\t");
|
|
auto func = GenerateServerFuncName(method.get());
|
|
printer->Print(vars, func.c_str());
|
|
printer->Print("\n");
|
|
}
|
|
printer->Print("}\n\n");
|
|
|
|
printer->Print(vars, "$ACCESS$ extension $ServiceName$Provider {\n");
|
|
printer->Print(vars,
|
|
"\tvar serviceName: String { return "
|
|
"\"$PATH$$ServiceName$\" }\n");
|
|
printer->Print(
|
|
"\tfunc handleMethod(_ methodName: String, callHandlerContext: "
|
|
"CallHandlerContext) -> GRPCCallHandler? {\n");
|
|
printer->Print("\t\tswitch methodName {\n");
|
|
for (auto it = 0; it < service->method_count(); it++) {
|
|
auto method = service->method(it);
|
|
vars["Input"] = GenerateMessage(method->get_input_type_name());
|
|
vars["Output"] = GenerateMessage(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("\t\tdefault: return nil;\n");
|
|
printer->Print("\t\t}\n");
|
|
printer->Print("\t}\n\n");
|
|
printer->Print("}\n\n");
|
|
}
|
|
|
|
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["ServiceName"] = service->name();
|
|
vars["ACCESS"] = "public";
|
|
auto printer = file->CreatePrinter(&output);
|
|
printer->Print(vars,
|
|
"/// Usage: instantiate $ServiceName$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 += "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
|