Skip to content
Snippets Groups Projects
Select Git revision
  • ff4f004b5e478116a371d19ce4a1d64c8c0bed29
  • master default protected
  • arm-aarch-platform
  • arm-platform
  • vjpai-patch-3
  • vjpai-patch-1
  • v1.27.x
  • jtattermusch-patch-2
  • jtattermusch-patch-1
  • update-java-worker-example-in-performance-docs
  • revert-21805-revert-21797-reintroduce_21527
  • revert-21804-tls-credentials-1
  • zhen_cleanup_namecheck
  • revert-21806-revert-21767-revert-21725-revert-21680-cq_ordering
  • vjpai-patch-2
  • revert-21766-tls-credentials-1
  • revert-21640-change_local_tcp_security_level
  • revert-21680-cq_ordering
  • revert-21527-unify_boringssl_deps2
  • revert-20803-grpclb_stabilization
  • fix-kokoro-rvm-key
  • v1.27.0
  • v1.27.0-pre2
  • v1.27.0-pre1
  • v1.26.0
  • v1.26.0-pre1
  • v1.25.0
  • v1.25.0-pre1
  • v1.24.3
  • v1.24.2
  • v1.24.1
  • v1.23.1
  • v1.24.0
  • v1.24.0-pre2
  • v1.24.0-pre1
  • v1.22.1
  • v1.23.0
  • v1.23.0-pre1
  • v1.22.0
  • v1.22.0-pre1
  • v1.21.4
41 results

cpp_generator.cc

Blame
  • user avatar
    Masood Malekghassemi authored
    ac592456
    History
    cpp_generator.cc 46.84 KiB
    /*
     *
     * 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 <map>
    
    #include "src/compiler/cpp_generator.h"
    
    #include <sstream>
    
    namespace grpc_cpp_generator {
    namespace {
    
    template <class T>
    grpc::string as_string(T x) {
      std::ostringstream out;
      out << x;
      return out.str();
    }
    
    grpc::string FilenameIdentifier(const grpc::string &filename) {
      grpc::string result;
      for (unsigned i = 0; i < filename.size(); i++) {
        char c = filename[i];
        if (isalnum(c)) {
          result.push_back(c);
        } else {
          static char hex[] = "0123456789abcdef";
          result.push_back('_');
          result.push_back(hex[(c >> 4) & 0xf]);
          result.push_back(hex[c & 0xf]);
        }
      }
      return result;
    }
    }  // namespace
    
    template <class T, size_t N>
    T *array_end(T (&array)[N]) {
      return array + N;
    }
    
    void PrintIncludes(Printer *printer, const std::vector<grpc::string> &headers,
                       const Parameters &params) {
      std::map<grpc::string, grpc::string> vars;
    
      vars["l"] = params.use_system_headers ? '<' : '"';
      vars["r"] = params.use_system_headers ? '>' : '"';
    
      auto &s = params.grpc_search_path;
      if (!s.empty()) {
        vars["l"] += s;
        if (s[s.size() - 1] != '/') {
          vars["l"] += '/';
        }
      }
    
      for (auto i = headers.begin(); i != headers.end(); i++) {
        vars["h"] = *i;
        printer->Print(vars, "#include $l$$h$$r$\n");
      }
    }
    
    grpc::string GetHeaderPrologue(File *file, const Parameters & /*params*/) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
    
        vars["filename"] = file->filename();
        vars["filename_identifier"] = FilenameIdentifier(file->filename());
        vars["filename_base"] = file->filename_without_ext();
        vars["message_header_ext"] = file->message_header_ext();
    
        printer->Print(vars, "// Generated by the gRPC protobuf plugin.\n");
        printer->Print(vars,
                       "// If you make any local change, they will be lost.\n");
        printer->Print(vars, "// source: $filename$\n");
        grpc::string leading_comments = file->GetLeadingComments();
        if (!leading_comments.empty()) {
          printer->Print(vars, "// Original file comments:\n");
          printer->Print(leading_comments.c_str());
        }
        printer->Print(vars, "#ifndef GRPC_$filename_identifier$__INCLUDED\n");
        printer->Print(vars, "#define GRPC_$filename_identifier$__INCLUDED\n");
        printer->Print(vars, "\n");
        printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
        printer->Print(vars, "\n");
      }
      return output;
    }
    
    grpc::string GetHeaderIncludes(File *file, const Parameters &params) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
    
        static const char *headers_strs[] = {
            "grpc++/impl/codegen/async_stream.h",
            "grpc++/impl/codegen/async_unary_call.h",
            "grpc++/impl/codegen/proto_utils.h",
            "grpc++/impl/codegen/rpc_method.h",
            "grpc++/impl/codegen/service_type.h",
            "grpc++/impl/codegen/status.h",
            "grpc++/impl/codegen/stub_options.h",
            "grpc++/impl/codegen/sync_stream.h"};
        std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
        PrintIncludes(printer.get(), headers, params);
        printer->Print(vars, "\n");
        printer->Print(vars, "namespace grpc {\n");
        printer->Print(vars, "class CompletionQueue;\n");
        printer->Print(vars, "class Channel;\n");
        printer->Print(vars, "class RpcService;\n");
        printer->Print(vars, "class ServerCompletionQueue;\n");
        printer->Print(vars, "class ServerContext;\n");
        printer->Print(vars, "}  // namespace grpc\n\n");
    
        if (!file->package().empty()) {
          std::vector<grpc::string> parts = file->package_parts();
    
          for (auto part = parts.begin(); part != parts.end(); part++) {
            vars["part"] = *part;
            printer->Print(vars, "namespace $part$ {\n");
          }
          printer->Print(vars, "\n");
        }
      }
      return output;
    }
    
    void PrintHeaderClientMethodInterfaces(
        Printer *printer, const Method *method,
        std::map<grpc::string, grpc::string> *vars, bool is_public) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
    
      if (is_public) {
        if (method->NoStreaming()) {
          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 (method->ClientOnlyStreaming()) {
          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 (method->ServerOnlyStreaming()) {
          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 (method->BidiStreaming()) {
          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 (method->NoStreaming()) {
          printer->Print(
              *vars,
              "virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* "
              "Async$Method$Raw(::grpc::ClientContext* context, "
              "const $Request$& request, "
              "::grpc::CompletionQueue* cq) = 0;\n");
        } else if (method->ClientOnlyStreaming()) {
          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 (method->ServerOnlyStreaming()) {
          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 (method->BidiStreaming()) {
          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(Printer *printer, const Method *method,
                                 std::map<grpc::string, grpc::string> *vars,
                                 bool is_public) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      if (is_public) {
        if (method->NoStreaming()) {
          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 (method->ClientOnlyStreaming()) {
          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 (method->ServerOnlyStreaming()) {
          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 (method->BidiStreaming()) {
          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 (method->NoStreaming()) {
          printer->Print(*vars,
                         "::grpc::ClientAsyncResponseReader< $Response$>* "
                         "Async$Method$Raw(::grpc::ClientContext* context, "
                         "const $Request$& request, "
                         "::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n");
        } else if (method->ClientOnlyStreaming()) {
          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 (method->ServerOnlyStreaming()) {
          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 (method->BidiStreaming()) {
          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");
        }
      }
    }
    
    void PrintHeaderClientMethodData(Printer *printer, const Method *method,
                                     std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      printer->Print(*vars, "const ::grpc::RpcMethod rpcmethod_$Method$_;\n");
    }
    
    void PrintHeaderServerMethodSync(Printer *printer, const Method *method,
                                     std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      printer->Print(method->GetLeadingComments().c_str());
      if (method->NoStreaming()) {
        printer->Print(*vars,
                       "virtual ::grpc::Status $Method$("
                       "::grpc::ServerContext* context, const $Request$* request, "
                       "$Response$* response);\n");
      } else if (method->ClientOnlyStreaming()) {
        printer->Print(*vars,
                       "virtual ::grpc::Status $Method$("
                       "::grpc::ServerContext* context, "
                       "::grpc::ServerReader< $Request$>* reader, "
                       "$Response$* response);\n");
      } else if (method->ServerOnlyStreaming()) {
        printer->Print(*vars,
                       "virtual ::grpc::Status $Method$("
                       "::grpc::ServerContext* context, const $Request$* request, "
                       "::grpc::ServerWriter< $Response$>* writer);\n");
      } else if (method->BidiStreaming()) {
        printer->Print(
            *vars,
            "virtual ::grpc::Status $Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerReaderWriter< $Response$, $Request$>* stream);"
            "\n");
      }
      printer->Print(method->GetTrailingComments().c_str());
    }
    
    void PrintHeaderServerMethodAsync(Printer *printer, const Method *method,
                                      std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      printer->Print(*vars, "template <class BaseClass>\n");
      printer->Print(*vars,
                     "class WithAsyncMethod_$Method$ : public BaseClass {\n");
      printer->Print(
          " private:\n"
          "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
      printer->Print(" public:\n");
      printer->Indent();
      printer->Print(*vars,
                     "WithAsyncMethod_$Method$() {\n"
                     "  ::grpc::Service::MarkMethodAsync($Idx$);\n"
                     "}\n");
      printer->Print(*vars,
                     "~WithAsyncMethod_$Method$() GRPC_OVERRIDE {\n"
                     "  BaseClassMustBeDerivedFromService(this);\n"
                     "}\n");
      if (method->NoStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, const $Request$* request, "
            "$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
        printer->Print(
            *vars,
            "void Request$Method$("
            "::grpc::ServerContext* context, $Request$* request, "
            "::grpc::ServerAsyncResponseWriter< $Response$>* response, "
            "::grpc::CompletionQueue* new_call_cq, "
            "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
        printer->Print(*vars,
                       "  ::grpc::Service::RequestAsyncUnary($Idx$, context, "
                       "request, response, new_call_cq, notification_cq, tag);\n");
        printer->Print("}\n");
      } else if (method->ClientOnlyStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerReader< $Request$>* reader, "
            "$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
        printer->Print(
            *vars,
            "void Request$Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerAsyncReader< $Response$, $Request$>* reader, "
            "::grpc::CompletionQueue* new_call_cq, "
            "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
        printer->Print(*vars,
                       "  ::grpc::Service::RequestAsyncClientStreaming($Idx$, "
                       "context, reader, new_call_cq, notification_cq, tag);\n");
        printer->Print("}\n");
      } else if (method->ServerOnlyStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, const $Request$* request, "
            "::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE "
            "{\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
        printer->Print(
            *vars,
            "void Request$Method$("
            "::grpc::ServerContext* context, $Request$* request, "
            "::grpc::ServerAsyncWriter< $Response$>* writer, "
            "::grpc::CompletionQueue* new_call_cq, "
            "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
        printer->Print(
            *vars,
            "  ::grpc::Service::RequestAsyncServerStreaming($Idx$, "
            "context, request, writer, new_call_cq, notification_cq, tag);\n");
        printer->Print("}\n");
      } else if (method->BidiStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
            "GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
        printer->Print(
            *vars,
            "void Request$Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerAsyncReaderWriter< $Response$, $Request$>* stream, "
            "::grpc::CompletionQueue* new_call_cq, "
            "::grpc::ServerCompletionQueue* notification_cq, void *tag) {\n");
        printer->Print(*vars,
                       "  ::grpc::Service::RequestAsyncBidiStreaming($Idx$, "
                       "context, stream, new_call_cq, notification_cq, tag);\n");
        printer->Print("}\n");
      }
      printer->Outdent();
      printer->Print(*vars, "};\n");
    }
    
    void PrintHeaderServerMethodGeneric(
        Printer *printer, const Method *method,
        std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      printer->Print(*vars, "template <class BaseClass>\n");
      printer->Print(*vars,
                     "class WithGenericMethod_$Method$ : public BaseClass {\n");
      printer->Print(
          " private:\n"
          "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
      printer->Print(" public:\n");
      printer->Indent();
      printer->Print(*vars,
                     "WithGenericMethod_$Method$() {\n"
                     "  ::grpc::Service::MarkMethodGeneric($Idx$);\n"
                     "}\n");
      printer->Print(*vars,
                     "~WithGenericMethod_$Method$() GRPC_OVERRIDE {\n"
                     "  BaseClassMustBeDerivedFromService(this);\n"
                     "}\n");
      if (method->NoStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, const $Request$* request, "
            "$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
      } else if (method->ClientOnlyStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerReader< $Request$>* reader, "
            "$Response$* response) GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
      } else if (method->ServerOnlyStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, const $Request$* request, "
            "::grpc::ServerWriter< $Response$>* writer) GRPC_FINAL GRPC_OVERRIDE "
            "{\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
      } else if (method->BidiStreaming()) {
        printer->Print(
            *vars,
            "// disable synchronous version of this method\n"
            "::grpc::Status $Method$("
            "::grpc::ServerContext* context, "
            "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
            "GRPC_FINAL GRPC_OVERRIDE {\n"
            "  abort();\n"
            "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
            "}\n");
      }
      printer->Outdent();
      printer->Print(*vars, "};\n");
    }
    
    void PrintHeaderService(Printer *printer, const Service *service,
                            std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Service"] = service->name();
    
      printer->Print(service->GetLeadingComments().c_str());
      printer->Print(*vars,
                     "class $Service$ GRPC_FINAL {\n"
                     " public:\n");
      printer->Indent();
    
      // Client side
      printer->Print(
          "class StubInterface {\n"
          " public:\n");
      printer->Indent();
      printer->Print("virtual ~StubInterface() {}\n");
      for (int i = 0; i < service->method_count(); ++i) {
        printer->Print(service->method(i)->GetLeadingComments().c_str());
        PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,
                                          true);
        printer->Print(service->method(i)->GetTrailingComments().c_str());
      }
      printer->Outdent();
      printer->Print("private:\n");
      printer->Indent();
      for (int i = 0; i < service->method_count(); ++i) {
        PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,
                                          false);
      }
      printer->Outdent();
      printer->Print("};\n");
      printer->Print(
          "class Stub GRPC_FINAL : public StubInterface"
          " {\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).get(), vars, true);
      }
      printer->Outdent();
      printer->Print("\n private:\n");
      printer->Indent();
      printer->Print("std::shared_ptr< ::grpc::ChannelInterface> channel_;\n");
      for (int i = 0; i < service->method_count(); ++i) {
        PrintHeaderClientMethod(printer, service->method(i).get(), vars, false);
      }
      for (int i = 0; i < service->method_count(); ++i) {
        PrintHeaderClientMethodData(printer, service->method(i).get(), vars);
      }
      printer->Outdent();
      printer->Print("};\n");
      printer->Print(
          "static std::unique_ptr<Stub> NewStub(const std::shared_ptr< "
          "::grpc::ChannelInterface>& channel, "
          "const ::grpc::StubOptions& options = ::grpc::StubOptions());\n");
    
      printer->Print("\n");
    
      // Server side - base
      printer->Print(
          "class Service : public ::grpc::Service {\n"
          " public:\n");
      printer->Indent();
      printer->Print("Service();\n");
      printer->Print("virtual ~Service();\n");
      for (int i = 0; i < service->method_count(); ++i) {
        PrintHeaderServerMethodSync(printer, service->method(i).get(), vars);
      }
      printer->Outdent();
      printer->Print("};\n");
    
      // Server side - Asynchronous
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["Idx"] = as_string(i);
        PrintHeaderServerMethodAsync(printer, service->method(i).get(), vars);
      }
    
      printer->Print("typedef ");
    
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["method_name"] = service->method(i).get()->name();
        printer->Print(*vars, "WithAsyncMethod_$method_name$<");
      }
      printer->Print("Service");
      for (int i = 0; i < service->method_count(); ++i) {
        printer->Print(" >");
      }
      printer->Print(" AsyncService;\n");
    
      // Server side - Generic
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["Idx"] = as_string(i);
        PrintHeaderServerMethodGeneric(printer, service->method(i).get(), vars);
      }
    
      printer->Outdent();
      printer->Print("};\n");
      printer->Print(service->GetTrailingComments().c_str());
    }
    
    grpc::string GetHeaderServices(File *file, const Parameters &params) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
        // Package string is empty or ends with a dot. It is used to fully qualify
        // method names.
        vars["Package"] = file->package();
        if (!file->package().empty()) {
          vars["Package"].append(".");
        }
    
        if (!params.services_namespace.empty()) {
          vars["services_namespace"] = params.services_namespace;
          printer->Print(vars, "\nnamespace $services_namespace$ {\n\n");
        }
    
        for (int i = 0; i < file->service_count(); ++i) {
          PrintHeaderService(printer.get(), file->service(i).get(), &vars);
          printer->Print("\n");
        }
    
        if (!params.services_namespace.empty()) {
          printer->Print(vars, "}  // namespace $services_namespace$\n\n");
        }
      }
      return output;
    }
    
    grpc::string GetHeaderEpilogue(File *file, const Parameters & /*params*/) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
    
        vars["filename"] = file->filename();
        vars["filename_identifier"] = FilenameIdentifier(file->filename());
    
        if (!file->package().empty()) {
          std::vector<grpc::string> parts = file->package_parts();
    
          for (auto part = parts.rbegin(); part != parts.rend(); part++) {
            vars["part"] = *part;
            printer->Print(vars, "}  // namespace $part$\n");
          }
          printer->Print(vars, "\n");
        }
    
        printer->Print(vars, "\n");
        printer->Print(vars, "#endif  // GRPC_$filename_identifier$__INCLUDED\n");
    
        printer->Print(file->GetTrailingComments().c_str());
      }
      return output;
    }
    
    grpc::string GetSourcePrologue(File *file, const Parameters & /*params*/) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
    
        vars["filename"] = file->filename();
        vars["filename_base"] = file->filename_without_ext();
        vars["message_header_ext"] = file->message_header_ext();
        vars["service_header_ext"] = file->service_header_ext();
    
        printer->Print(vars, "// Generated by the gRPC protobuf plugin.\n");
        printer->Print(vars,
                       "// If you make any local change, they will be lost.\n");
        printer->Print(vars, "// source: $filename$\n\n");
    
        printer->Print(vars, "#include \"$filename_base$$message_header_ext$\"\n");
        printer->Print(vars, "#include \"$filename_base$$service_header_ext$\"\n");
        printer->Print(vars, file->additional_headers().c_str());
        printer->Print(vars, "\n");
      }
      return output;
    }
    
    grpc::string GetSourceIncludes(File *file, const Parameters &params) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
    
        static const char *headers_strs[] = {
            "grpc++/impl/codegen/async_stream.h",
            "grpc++/impl/codegen/async_unary_call.h",
            "grpc++/impl/codegen/channel_interface.h",
            "grpc++/impl/codegen/client_unary_call.h",
            "grpc++/impl/codegen/method_handler_impl.h",
            "grpc++/impl/codegen/rpc_service_method.h",
            "grpc++/impl/codegen/service_type.h",
            "grpc++/impl/codegen/sync_stream.h"};
        std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
        PrintIncludes(printer.get(), headers, params);
    
        if (!file->package().empty()) {
          std::vector<grpc::string> parts = file->package_parts();
    
          for (auto part = parts.begin(); part != parts.end(); part++) {
            vars["part"] = *part;
            printer->Print(vars, "namespace $part$ {\n");
          }
        }
    
        printer->Print(vars, "\n");
      }
      return output;
    }
    
    void PrintSourceClientMethod(Printer *printer, const Method *method,
                                 std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      if (method->NoStreaming()) {
        printer->Print(*vars,
                       "::grpc::Status $ns$$Service$::Stub::$Method$("
                       "::grpc::ClientContext* context, "
                       "const $Request$& request, $Response$* response) {\n");
        printer->Print(*vars,
                       "  return ::grpc::BlockingUnaryCall(channel_.get(), "
                       "rpcmethod_$Method$_, "
                       "context, request, response);\n"
                       "}\n\n");
        printer->Print(
            *vars,
            "::grpc::ClientAsyncResponseReader< $Response$>* "
            "$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, "
            "const $Request$& request, "
            "::grpc::CompletionQueue* cq) {\n");
        printer->Print(*vars,
                       "  return new "
                       "::grpc::ClientAsyncResponseReader< $Response$>("
                       "channel_.get(), cq, "
                       "rpcmethod_$Method$_, "
                       "context, request);\n"
                       "}\n\n");
      } else if (method->ClientOnlyStreaming()) {
        printer->Print(*vars,
                       "::grpc::ClientWriter< $Request$>* "
                       "$ns$$Service$::Stub::$Method$Raw("
                       "::grpc::ClientContext* context, $Response$* response) {\n");
        printer->Print(*vars,
                       "  return new ::grpc::ClientWriter< $Request$>("
                       "channel_.get(), "
                       "rpcmethod_$Method$_, "
                       "context, response);\n"
                       "}\n\n");
        printer->Print(*vars,
                       "::grpc::ClientAsyncWriter< $Request$>* "
                       "$ns$$Service$::Stub::Async$Method$Raw("
                       "::grpc::ClientContext* context, $Response$* response, "
                       "::grpc::CompletionQueue* cq, void* tag) {\n");
        printer->Print(*vars,
                       "  return new ::grpc::ClientAsyncWriter< $Request$>("
                       "channel_.get(), cq, "
                       "rpcmethod_$Method$_, "
                       "context, response, tag);\n"
                       "}\n\n");
      } else if (method->ServerOnlyStreaming()) {
        printer->Print(
            *vars,
            "::grpc::ClientReader< $Response$>* "
            "$ns$$Service$::Stub::$Method$Raw("
            "::grpc::ClientContext* context, const $Request$& request) {\n");
        printer->Print(*vars,
                       "  return new ::grpc::ClientReader< $Response$>("
                       "channel_.get(), "
                       "rpcmethod_$Method$_, "
                       "context, request);\n"
                       "}\n\n");
        printer->Print(*vars,
                       "::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 new ::grpc::ClientAsyncReader< $Response$>("
                       "channel_.get(), cq, "
                       "rpcmethod_$Method$_, "
                       "context, request, tag);\n"
                       "}\n\n");
      } else if (method->BidiStreaming()) {
        printer->Print(
            *vars,
            "::grpc::ClientReaderWriter< $Request$, $Response$>* "
            "$ns$$Service$::Stub::$Method$Raw(::grpc::ClientContext* context) {\n");
        printer->Print(*vars,
                       "  return new ::grpc::ClientReaderWriter< "
                       "$Request$, $Response$>("
                       "channel_.get(), "
                       "rpcmethod_$Method$_, "
                       "context);\n"
                       "}\n\n");
        printer->Print(
            *vars,
            "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* "
            "$ns$$Service$::Stub::Async$Method$Raw(::grpc::ClientContext* context, "
            "::grpc::CompletionQueue* cq, void* tag) {\n");
        printer->Print(*vars,
                       "  return new "
                       "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>("
                       "channel_.get(), cq, "
                       "rpcmethod_$Method$_, "
                       "context, tag);\n"
                       "}\n\n");
      }
    }
    
    void PrintSourceServerMethod(Printer *printer, const Method *method,
                                 std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Method"] = method->name();
      (*vars)["Request"] = method->input_type_name();
      (*vars)["Response"] = method->output_type_name();
      if (method->NoStreaming()) {
        printer->Print(*vars,
                       "::grpc::Status $ns$$Service$::Service::$Method$("
                       "::grpc::ServerContext* context, "
                       "const $Request$* request, $Response$* response) {\n");
        printer->Print("  (void) context;\n");
        printer->Print("  (void) request;\n");
        printer->Print("  (void) response;\n");
        printer->Print(
            "  return ::grpc::Status("
            "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
        printer->Print("}\n\n");
      } else if (method->ClientOnlyStreaming()) {
        printer->Print(*vars,
                       "::grpc::Status $ns$$Service$::Service::$Method$("
                       "::grpc::ServerContext* context, "
                       "::grpc::ServerReader< $Request$>* reader, "
                       "$Response$* response) {\n");
        printer->Print("  (void) context;\n");
        printer->Print("  (void) reader;\n");
        printer->Print("  (void) response;\n");
        printer->Print(
            "  return ::grpc::Status("
            "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
        printer->Print("}\n\n");
      } else if (method->ServerOnlyStreaming()) {
        printer->Print(*vars,
                       "::grpc::Status $ns$$Service$::Service::$Method$("
                       "::grpc::ServerContext* context, "
                       "const $Request$* request, "
                       "::grpc::ServerWriter< $Response$>* writer) {\n");
        printer->Print("  (void) context;\n");
        printer->Print("  (void) request;\n");
        printer->Print("  (void) writer;\n");
        printer->Print(
            "  return ::grpc::Status("
            "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
        printer->Print("}\n\n");
      } else if (method->BidiStreaming()) {
        printer->Print(*vars,
                       "::grpc::Status $ns$$Service$::Service::$Method$("
                       "::grpc::ServerContext* context, "
                       "::grpc::ServerReaderWriter< $Response$, $Request$>* "
                       "stream) {\n");
        printer->Print("  (void) context;\n");
        printer->Print("  (void) stream;\n");
        printer->Print(
            "  return ::grpc::Status("
            "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
        printer->Print("}\n\n");
      }
    }
    
    void PrintSourceService(Printer *printer, const Service *service,
                            std::map<grpc::string, grpc::string> *vars) {
      (*vars)["Service"] = service->name();
    
      printer->Print(*vars,
                     "static const char* $prefix$$Service$_method_names[] = {\n");
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["Method"] = service->method(i).get()->name();
        printer->Print(*vars, "  \"/$Package$$Service$/$Method$\",\n");
      }
      printer->Print(*vars, "};\n\n");
    
      printer->Print(*vars,
                     "std::unique_ptr< $ns$$Service$::Stub> $ns$$Service$::NewStub("
                     "const std::shared_ptr< ::grpc::ChannelInterface>& channel, "
                     "const ::grpc::StubOptions& options) {\n"
                     "  std::unique_ptr< $ns$$Service$::Stub> stub(new "
                     "$ns$$Service$::Stub(channel));\n"
                     "  return stub;\n"
                     "}\n\n");
      printer->Print(*vars,
                     "$ns$$Service$::Stub::Stub(const std::shared_ptr< "
                     "::grpc::ChannelInterface>& channel)\n");
      printer->Indent();
      printer->Print(": channel_(channel)");
      for (int i = 0; i < service->method_count(); ++i) {
        auto method = service->method(i);
        (*vars)["Method"] = method->name();
        (*vars)["Idx"] = as_string(i);
        if (method->NoStreaming()) {
          (*vars)["StreamingType"] = "NORMAL_RPC";
        } else if (method->ClientOnlyStreaming()) {
          (*vars)["StreamingType"] = "CLIENT_STREAMING";
        } else if (method->ServerOnlyStreaming()) {
          (*vars)["StreamingType"] = "SERVER_STREAMING";
        } else {
          (*vars)["StreamingType"] = "BIDI_STREAMING";
        }
        printer->Print(*vars,
                       ", rpcmethod_$Method$_("
                       "$prefix$$Service$_method_names[$Idx$], "
                       "::grpc::RpcMethod::$StreamingType$, "
                       "channel"
                       ")\n");
      }
      printer->Print("{}\n\n");
      printer->Outdent();
    
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["Idx"] = as_string(i);
        PrintSourceClientMethod(printer, service->method(i).get(), vars);
      }
    
      printer->Print(*vars, "$ns$$Service$::Service::Service() {\n");
      printer->Indent();
      printer->Print(*vars, "(void)$prefix$$Service$_method_names;\n");
      for (int i = 0; i < service->method_count(); ++i) {
        auto method = service->method(i);
        (*vars)["Idx"] = as_string(i);
        (*vars)["Method"] = method->name();
        (*vars)["Request"] = method->input_type_name();
        (*vars)["Response"] = method->output_type_name();
        if (method->NoStreaming()) {
          printer->Print(
              *vars,
              "AddMethod(new ::grpc::RpcServiceMethod(\n"
              "    $prefix$$Service$_method_names[$Idx$],\n"
              "    ::grpc::RpcMethod::NORMAL_RPC,\n"
              "    new ::grpc::RpcMethodHandler< $ns$$Service$::Service, "
              "$Request$, "
              "$Response$>(\n"
              "        std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\n");
        } else if (method->ClientOnlyStreaming()) {
          printer->Print(
              *vars,
              "AddMethod(new ::grpc::RpcServiceMethod(\n"
              "    $prefix$$Service$_method_names[$Idx$],\n"
              "    ::grpc::RpcMethod::CLIENT_STREAMING,\n"
              "    new ::grpc::ClientStreamingHandler< "
              "$ns$$Service$::Service, $Request$, $Response$>(\n"
              "        std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\n");
        } else if (method->ServerOnlyStreaming()) {
          printer->Print(
              *vars,
              "AddMethod(new ::grpc::RpcServiceMethod(\n"
              "    $prefix$$Service$_method_names[$Idx$],\n"
              "    ::grpc::RpcMethod::SERVER_STREAMING,\n"
              "    new ::grpc::ServerStreamingHandler< "
              "$ns$$Service$::Service, $Request$, $Response$>(\n"
              "        std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\n");
        } else if (method->BidiStreaming()) {
          printer->Print(
              *vars,
              "AddMethod(new ::grpc::RpcServiceMethod(\n"
              "    $prefix$$Service$_method_names[$Idx$],\n"
              "    ::grpc::RpcMethod::BIDI_STREAMING,\n"
              "    new ::grpc::BidiStreamingHandler< "
              "$ns$$Service$::Service, $Request$, $Response$>(\n"
              "        std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\n");
        }
      }
      printer->Outdent();
      printer->Print(*vars, "}\n\n");
      printer->Print(*vars,
                     "$ns$$Service$::Service::~Service() {\n"
                     "}\n\n");
      for (int i = 0; i < service->method_count(); ++i) {
        (*vars)["Idx"] = as_string(i);
        PrintSourceServerMethod(printer, service->method(i).get(), vars);
      }
    }
    
    grpc::string GetSourceServices(File *file, const Parameters &params) {
      grpc::string output;
      {
        // Scope the output stream so it closes and finalizes output to the string.
        auto printer = file->CreatePrinter(&output);
        std::map<grpc::string, grpc::string> vars;
        // Package string is empty or ends with a dot. It is used to fully qualify
        // method names.
        vars["Package"] = file->package();
        if (!file->package().empty()) {
          vars["Package"].append(".");
        }
        if (!params.services_namespace.empty()) {
          vars["ns"] = params.services_namespace + "::";
          vars["prefix"] = params.services_namespace;
        } else {
          vars["ns"] = "";
          vars["prefix"] = "";
        }
    
        for (int i = 0; i < file->service_count(); ++i) {
          PrintSourceService(printer.get(), file->service(i).get(), &vars);
          printer->Print("\n");
        }
      }
      return output;
    }
    
    grpc::string GetSourceEpilogue(File *file, const Parameters & /*params*/) {
      grpc::string temp;
    
      if (!file->package().empty()) {
        std::vector<grpc::string> parts = file->package_parts();
    
        for (auto part = parts.begin(); part != parts.end(); part++) {
          temp.append("}  // namespace ");
          temp.append(*part);
          temp.append("\n");
        }
        temp.append("\n");
      }
    
      return temp;
    }
    
    }  // namespace grpc_cpp_generator