grpc/src/compiler/swift_generator.cc - RealtimeRoboticsGroup/test - Gitiles

 /*
  * 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
	/*
	* 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