// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: gobgp.proto

#include "gobgp.pb.h"
#include "gobgp.grpc.pb.h"

#include <functional>
#include <grpcpp/support/async_stream.h>
#include <grpcpp/support/async_unary_call.h>
#include <grpcpp/impl/channel_interface.h>
#include <grpcpp/impl/client_unary_call.h>
#include <grpcpp/support/client_callback.h>
#include <grpcpp/support/message_allocator.h>
#include <grpcpp/support/method_handler.h>
#include <grpcpp/impl/rpc_service_method.h>
#include <grpcpp/support/server_callback.h>
#include <grpcpp/impl/server_callback_handlers.h>
#include <grpcpp/server_context.h>
#include <grpcpp/impl/service_type.h>
#include <grpcpp/support/sync_stream.h>
#include <grpcpp/ports_def.inc>
namespace apipb {

static const char* GobgpApi_method_names[] = {
  "/apipb.GobgpApi/StartBgp",
  "/apipb.GobgpApi/StopBgp",
  "/apipb.GobgpApi/GetBgp",
  "/apipb.GobgpApi/WatchEvent",
  "/apipb.GobgpApi/AddPeer",
  "/apipb.GobgpApi/DeletePeer",
  "/apipb.GobgpApi/ListPeer",
  "/apipb.GobgpApi/UpdatePeer",
  "/apipb.GobgpApi/ResetPeer",
  "/apipb.GobgpApi/ShutdownPeer",
  "/apipb.GobgpApi/EnablePeer",
  "/apipb.GobgpApi/DisablePeer",
  "/apipb.GobgpApi/AddPeerGroup",
  "/apipb.GobgpApi/DeletePeerGroup",
  "/apipb.GobgpApi/ListPeerGroup",
  "/apipb.GobgpApi/UpdatePeerGroup",
  "/apipb.GobgpApi/AddDynamicNeighbor",
  "/apipb.GobgpApi/ListDynamicNeighbor",
  "/apipb.GobgpApi/DeleteDynamicNeighbor",
  "/apipb.GobgpApi/AddPath",
  "/apipb.GobgpApi/DeletePath",
  "/apipb.GobgpApi/ListPath",
  "/apipb.GobgpApi/AddPathStream",
  "/apipb.GobgpApi/GetTable",
  "/apipb.GobgpApi/AddVrf",
  "/apipb.GobgpApi/DeleteVrf",
  "/apipb.GobgpApi/ListVrf",
  "/apipb.GobgpApi/AddPolicy",
  "/apipb.GobgpApi/DeletePolicy",
  "/apipb.GobgpApi/ListPolicy",
  "/apipb.GobgpApi/SetPolicies",
  "/apipb.GobgpApi/AddDefinedSet",
  "/apipb.GobgpApi/DeleteDefinedSet",
  "/apipb.GobgpApi/ListDefinedSet",
  "/apipb.GobgpApi/AddStatement",
  "/apipb.GobgpApi/DeleteStatement",
  "/apipb.GobgpApi/ListStatement",
  "/apipb.GobgpApi/AddPolicyAssignment",
  "/apipb.GobgpApi/DeletePolicyAssignment",
  "/apipb.GobgpApi/ListPolicyAssignment",
  "/apipb.GobgpApi/SetPolicyAssignment",
  "/apipb.GobgpApi/AddRpki",
  "/apipb.GobgpApi/DeleteRpki",
  "/apipb.GobgpApi/ListRpki",
  "/apipb.GobgpApi/EnableRpki",
  "/apipb.GobgpApi/DisableRpki",
  "/apipb.GobgpApi/ResetRpki",
  "/apipb.GobgpApi/ListRpkiTable",
  "/apipb.GobgpApi/EnableZebra",
  "/apipb.GobgpApi/EnableMrt",
  "/apipb.GobgpApi/DisableMrt",
  "/apipb.GobgpApi/AddBmp",
  "/apipb.GobgpApi/DeleteBmp",
  "/apipb.GobgpApi/ListBmp",
  "/apipb.GobgpApi/SetLogLevel",
};

std::unique_ptr< GobgpApi::Stub> GobgpApi::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
  (void)options;
  std::unique_ptr< GobgpApi::Stub> stub(new GobgpApi::Stub(channel, options));
  return stub;
}

GobgpApi::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_StartBgp_(GobgpApi_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_StopBgp_(GobgpApi_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetBgp_(GobgpApi_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_WatchEvent_(GobgpApi_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_AddPeer_(GobgpApi_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeletePeer_(GobgpApi_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPeer_(GobgpApi_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_UpdatePeer_(GobgpApi_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ResetPeer_(GobgpApi_method_names[8], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ShutdownPeer_(GobgpApi_method_names[9], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_EnablePeer_(GobgpApi_method_names[10], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DisablePeer_(GobgpApi_method_names[11], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddPeerGroup_(GobgpApi_method_names[12], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeletePeerGroup_(GobgpApi_method_names[13], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPeerGroup_(GobgpApi_method_names[14], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_UpdatePeerGroup_(GobgpApi_method_names[15], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddDynamicNeighbor_(GobgpApi_method_names[16], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListDynamicNeighbor_(GobgpApi_method_names[17], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_DeleteDynamicNeighbor_(GobgpApi_method_names[18], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddPath_(GobgpApi_method_names[19], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeletePath_(GobgpApi_method_names[20], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPath_(GobgpApi_method_names[21], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_AddPathStream_(GobgpApi_method_names[22], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
  , rpcmethod_GetTable_(GobgpApi_method_names[23], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddVrf_(GobgpApi_method_names[24], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteVrf_(GobgpApi_method_names[25], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListVrf_(GobgpApi_method_names[26], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_AddPolicy_(GobgpApi_method_names[27], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeletePolicy_(GobgpApi_method_names[28], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPolicy_(GobgpApi_method_names[29], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SetPolicies_(GobgpApi_method_names[30], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddDefinedSet_(GobgpApi_method_names[31], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteDefinedSet_(GobgpApi_method_names[32], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListDefinedSet_(GobgpApi_method_names[33], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_AddStatement_(GobgpApi_method_names[34], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteStatement_(GobgpApi_method_names[35], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListStatement_(GobgpApi_method_names[36], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_AddPolicyAssignment_(GobgpApi_method_names[37], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeletePolicyAssignment_(GobgpApi_method_names[38], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListPolicyAssignment_(GobgpApi_method_names[39], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SetPolicyAssignment_(GobgpApi_method_names[40], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddRpki_(GobgpApi_method_names[41], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteRpki_(GobgpApi_method_names[42], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListRpki_(GobgpApi_method_names[43], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_EnableRpki_(GobgpApi_method_names[44], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DisableRpki_(GobgpApi_method_names[45], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ResetRpki_(GobgpApi_method_names[46], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListRpkiTable_(GobgpApi_method_names[47], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_EnableZebra_(GobgpApi_method_names[48], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_EnableMrt_(GobgpApi_method_names[49], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DisableMrt_(GobgpApi_method_names[50], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_AddBmp_(GobgpApi_method_names[51], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteBmp_(GobgpApi_method_names[52], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListBmp_(GobgpApi_method_names[53], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
  , rpcmethod_SetLogLevel_(GobgpApi_method_names[54], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status GobgpApi::Stub::StartBgp(::grpc::ClientContext* context, const ::apipb::StartBgpRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::StartBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StartBgp_, context, request, response);
}

void GobgpApi::Stub::async::StartBgp(::grpc::ClientContext* context, const ::apipb::StartBgpRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::StartBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartBgp_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::StartBgp(::grpc::ClientContext* context, const ::apipb::StartBgpRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StartBgp_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncStartBgpRaw(::grpc::ClientContext* context, const ::apipb::StartBgpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::StartBgpRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StartBgp_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncStartBgpRaw(::grpc::ClientContext* context, const ::apipb::StartBgpRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStartBgpRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::StopBgp(::grpc::ClientContext* context, const ::apipb::StopBgpRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::StopBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_StopBgp_, context, request, response);
}

void GobgpApi::Stub::async::StopBgp(::grpc::ClientContext* context, const ::apipb::StopBgpRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::StopBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopBgp_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::StopBgp(::grpc::ClientContext* context, const ::apipb::StopBgpRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_StopBgp_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncStopBgpRaw(::grpc::ClientContext* context, const ::apipb::StopBgpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::StopBgpRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_StopBgp_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncStopBgpRaw(::grpc::ClientContext* context, const ::apipb::StopBgpRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncStopBgpRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::GetBgp(::grpc::ClientContext* context, const ::apipb::GetBgpRequest& request, ::apipb::GetBgpResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::GetBgpRequest, ::apipb::GetBgpResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetBgp_, context, request, response);
}

void GobgpApi::Stub::async::GetBgp(::grpc::ClientContext* context, const ::apipb::GetBgpRequest* request, ::apipb::GetBgpResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::GetBgpRequest, ::apipb::GetBgpResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBgp_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::GetBgp(::grpc::ClientContext* context, const ::apipb::GetBgpRequest* request, ::apipb::GetBgpResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetBgp_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::apipb::GetBgpResponse>* GobgpApi::Stub::PrepareAsyncGetBgpRaw(::grpc::ClientContext* context, const ::apipb::GetBgpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::apipb::GetBgpResponse, ::apipb::GetBgpRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetBgp_, context, request);
}

::grpc::ClientAsyncResponseReader< ::apipb::GetBgpResponse>* GobgpApi::Stub::AsyncGetBgpRaw(::grpc::ClientContext* context, const ::apipb::GetBgpRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetBgpRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::WatchEventResponse>* GobgpApi::Stub::WatchEventRaw(::grpc::ClientContext* context, const ::apipb::WatchEventRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::WatchEventResponse>::Create(channel_.get(), rpcmethod_WatchEvent_, context, request);
}

void GobgpApi::Stub::async::WatchEvent(::grpc::ClientContext* context, const ::apipb::WatchEventRequest* request, ::grpc::ClientReadReactor< ::apipb::WatchEventResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::WatchEventResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_WatchEvent_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::WatchEventResponse>* GobgpApi::Stub::AsyncWatchEventRaw(::grpc::ClientContext* context, const ::apipb::WatchEventRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::WatchEventResponse>::Create(channel_.get(), cq, rpcmethod_WatchEvent_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::WatchEventResponse>* GobgpApi::Stub::PrepareAsyncWatchEventRaw(::grpc::ClientContext* context, const ::apipb::WatchEventRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::WatchEventResponse>::Create(channel_.get(), cq, rpcmethod_WatchEvent_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::AddPeer(::grpc::ClientContext* context, const ::apipb::AddPeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPeer_, context, request, response);
}

void GobgpApi::Stub::async::AddPeer(::grpc::ClientContext* context, const ::apipb::AddPeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddPeer(::grpc::ClientContext* context, const ::apipb::AddPeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddPeerRaw(::grpc::ClientContext* context, const ::apipb::AddPeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddPeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddPeerRaw(::grpc::ClientContext* context, const ::apipb::AddPeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddPeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeletePeer(::grpc::ClientContext* context, const ::apipb::DeletePeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeletePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeletePeer_, context, request, response);
}

void GobgpApi::Stub::async::DeletePeer(::grpc::ClientContext* context, const ::apipb::DeletePeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeletePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeletePeer(::grpc::ClientContext* context, const ::apipb::DeletePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeletePeerRaw(::grpc::ClientContext* context, const ::apipb::DeletePeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeletePeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeletePeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeletePeerRaw(::grpc::ClientContext* context, const ::apipb::DeletePeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeletePeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListPeerResponse>* GobgpApi::Stub::ListPeerRaw(::grpc::ClientContext* context, const ::apipb::ListPeerRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListPeerResponse>::Create(channel_.get(), rpcmethod_ListPeer_, context, request);
}

void GobgpApi::Stub::async::ListPeer(::grpc::ClientContext* context, const ::apipb::ListPeerRequest* request, ::grpc::ClientReadReactor< ::apipb::ListPeerResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListPeerResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListPeer_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListPeerResponse>* GobgpApi::Stub::AsyncListPeerRaw(::grpc::ClientContext* context, const ::apipb::ListPeerRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPeerResponse>::Create(channel_.get(), cq, rpcmethod_ListPeer_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListPeerResponse>* GobgpApi::Stub::PrepareAsyncListPeerRaw(::grpc::ClientContext* context, const ::apipb::ListPeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPeerResponse>::Create(channel_.get(), cq, rpcmethod_ListPeer_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::UpdatePeer(::grpc::ClientContext* context, const ::apipb::UpdatePeerRequest& request, ::apipb::UpdatePeerResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::UpdatePeerRequest, ::apipb::UpdatePeerResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UpdatePeer_, context, request, response);
}

void GobgpApi::Stub::async::UpdatePeer(::grpc::ClientContext* context, const ::apipb::UpdatePeerRequest* request, ::apipb::UpdatePeerResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::UpdatePeerRequest, ::apipb::UpdatePeerResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdatePeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::UpdatePeer(::grpc::ClientContext* context, const ::apipb::UpdatePeerRequest* request, ::apipb::UpdatePeerResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdatePeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::apipb::UpdatePeerResponse>* GobgpApi::Stub::PrepareAsyncUpdatePeerRaw(::grpc::ClientContext* context, const ::apipb::UpdatePeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::apipb::UpdatePeerResponse, ::apipb::UpdatePeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UpdatePeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::apipb::UpdatePeerResponse>* GobgpApi::Stub::AsyncUpdatePeerRaw(::grpc::ClientContext* context, const ::apipb::UpdatePeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncUpdatePeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::ResetPeer(::grpc::ClientContext* context, const ::apipb::ResetPeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::ResetPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ResetPeer_, context, request, response);
}

void GobgpApi::Stub::async::ResetPeer(::grpc::ClientContext* context, const ::apipb::ResetPeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::ResetPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ResetPeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::ResetPeer(::grpc::ClientContext* context, const ::apipb::ResetPeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ResetPeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncResetPeerRaw(::grpc::ClientContext* context, const ::apipb::ResetPeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::ResetPeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ResetPeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncResetPeerRaw(::grpc::ClientContext* context, const ::apipb::ResetPeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncResetPeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::ShutdownPeer(::grpc::ClientContext* context, const ::apipb::ShutdownPeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::ShutdownPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ShutdownPeer_, context, request, response);
}

void GobgpApi::Stub::async::ShutdownPeer(::grpc::ClientContext* context, const ::apipb::ShutdownPeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::ShutdownPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ShutdownPeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::ShutdownPeer(::grpc::ClientContext* context, const ::apipb::ShutdownPeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ShutdownPeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncShutdownPeerRaw(::grpc::ClientContext* context, const ::apipb::ShutdownPeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::ShutdownPeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ShutdownPeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncShutdownPeerRaw(::grpc::ClientContext* context, const ::apipb::ShutdownPeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncShutdownPeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::EnablePeer(::grpc::ClientContext* context, const ::apipb::EnablePeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::EnablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EnablePeer_, context, request, response);
}

void GobgpApi::Stub::async::EnablePeer(::grpc::ClientContext* context, const ::apipb::EnablePeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::EnablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnablePeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::EnablePeer(::grpc::ClientContext* context, const ::apipb::EnablePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnablePeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncEnablePeerRaw(::grpc::ClientContext* context, const ::apipb::EnablePeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::EnablePeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EnablePeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncEnablePeerRaw(::grpc::ClientContext* context, const ::apipb::EnablePeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncEnablePeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DisablePeer(::grpc::ClientContext* context, const ::apipb::DisablePeerRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DisablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DisablePeer_, context, request, response);
}

void GobgpApi::Stub::async::DisablePeer(::grpc::ClientContext* context, const ::apipb::DisablePeerRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DisablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisablePeer_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DisablePeer(::grpc::ClientContext* context, const ::apipb::DisablePeerRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisablePeer_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDisablePeerRaw(::grpc::ClientContext* context, const ::apipb::DisablePeerRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DisablePeerRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DisablePeer_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDisablePeerRaw(::grpc::ClientContext* context, const ::apipb::DisablePeerRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDisablePeerRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddPeerGroup(::grpc::ClientContext* context, const ::apipb::AddPeerGroupRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddPeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPeerGroup_, context, request, response);
}

void GobgpApi::Stub::async::AddPeerGroup(::grpc::ClientContext* context, const ::apipb::AddPeerGroupRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddPeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeerGroup_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddPeerGroup(::grpc::ClientContext* context, const ::apipb::AddPeerGroupRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPeerGroup_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddPeerGroupRaw(::grpc::ClientContext* context, const ::apipb::AddPeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddPeerGroupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPeerGroup_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddPeerGroupRaw(::grpc::ClientContext* context, const ::apipb::AddPeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddPeerGroupRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeletePeerGroup(::grpc::ClientContext* context, const ::apipb::DeletePeerGroupRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeletePeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeletePeerGroup_, context, request, response);
}

void GobgpApi::Stub::async::DeletePeerGroup(::grpc::ClientContext* context, const ::apipb::DeletePeerGroupRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeletePeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePeerGroup_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeletePeerGroup(::grpc::ClientContext* context, const ::apipb::DeletePeerGroupRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePeerGroup_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeletePeerGroupRaw(::grpc::ClientContext* context, const ::apipb::DeletePeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeletePeerGroupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeletePeerGroup_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeletePeerGroupRaw(::grpc::ClientContext* context, const ::apipb::DeletePeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeletePeerGroupRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListPeerGroupResponse>* GobgpApi::Stub::ListPeerGroupRaw(::grpc::ClientContext* context, const ::apipb::ListPeerGroupRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListPeerGroupResponse>::Create(channel_.get(), rpcmethod_ListPeerGroup_, context, request);
}

void GobgpApi::Stub::async::ListPeerGroup(::grpc::ClientContext* context, const ::apipb::ListPeerGroupRequest* request, ::grpc::ClientReadReactor< ::apipb::ListPeerGroupResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListPeerGroupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListPeerGroup_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListPeerGroupResponse>* GobgpApi::Stub::AsyncListPeerGroupRaw(::grpc::ClientContext* context, const ::apipb::ListPeerGroupRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPeerGroupResponse>::Create(channel_.get(), cq, rpcmethod_ListPeerGroup_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListPeerGroupResponse>* GobgpApi::Stub::PrepareAsyncListPeerGroupRaw(::grpc::ClientContext* context, const ::apipb::ListPeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPeerGroupResponse>::Create(channel_.get(), cq, rpcmethod_ListPeerGroup_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::UpdatePeerGroup(::grpc::ClientContext* context, const ::apipb::UpdatePeerGroupRequest& request, ::apipb::UpdatePeerGroupResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::UpdatePeerGroupRequest, ::apipb::UpdatePeerGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UpdatePeerGroup_, context, request, response);
}

void GobgpApi::Stub::async::UpdatePeerGroup(::grpc::ClientContext* context, const ::apipb::UpdatePeerGroupRequest* request, ::apipb::UpdatePeerGroupResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::UpdatePeerGroupRequest, ::apipb::UpdatePeerGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdatePeerGroup_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::UpdatePeerGroup(::grpc::ClientContext* context, const ::apipb::UpdatePeerGroupRequest* request, ::apipb::UpdatePeerGroupResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdatePeerGroup_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::apipb::UpdatePeerGroupResponse>* GobgpApi::Stub::PrepareAsyncUpdatePeerGroupRaw(::grpc::ClientContext* context, const ::apipb::UpdatePeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::apipb::UpdatePeerGroupResponse, ::apipb::UpdatePeerGroupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UpdatePeerGroup_, context, request);
}

::grpc::ClientAsyncResponseReader< ::apipb::UpdatePeerGroupResponse>* GobgpApi::Stub::AsyncUpdatePeerGroupRaw(::grpc::ClientContext* context, const ::apipb::UpdatePeerGroupRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncUpdatePeerGroupRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::AddDynamicNeighborRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddDynamicNeighbor_, context, request, response);
}

void GobgpApi::Stub::async::AddDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::AddDynamicNeighborRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddDynamicNeighbor_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::AddDynamicNeighborRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddDynamicNeighbor_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::AddDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddDynamicNeighborRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddDynamicNeighbor_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::AddDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddDynamicNeighborRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListDynamicNeighborResponse>* GobgpApi::Stub::ListDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::ListDynamicNeighborRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListDynamicNeighborResponse>::Create(channel_.get(), rpcmethod_ListDynamicNeighbor_, context, request);
}

void GobgpApi::Stub::async::ListDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::ListDynamicNeighborRequest* request, ::grpc::ClientReadReactor< ::apipb::ListDynamicNeighborResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListDynamicNeighborResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListDynamicNeighbor_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListDynamicNeighborResponse>* GobgpApi::Stub::AsyncListDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::ListDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListDynamicNeighborResponse>::Create(channel_.get(), cq, rpcmethod_ListDynamicNeighbor_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListDynamicNeighborResponse>* GobgpApi::Stub::PrepareAsyncListDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::ListDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListDynamicNeighborResponse>::Create(channel_.get(), cq, rpcmethod_ListDynamicNeighbor_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::DeleteDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::DeleteDynamicNeighborRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteDynamicNeighbor_, context, request, response);
}

void GobgpApi::Stub::async::DeleteDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::DeleteDynamicNeighborRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteDynamicNeighbor_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteDynamicNeighbor(::grpc::ClientContext* context, const ::apipb::DeleteDynamicNeighborRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteDynamicNeighbor_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::DeleteDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteDynamicNeighborRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteDynamicNeighbor_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteDynamicNeighborRaw(::grpc::ClientContext* context, const ::apipb::DeleteDynamicNeighborRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteDynamicNeighborRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddPath(::grpc::ClientContext* context, const ::apipb::AddPathRequest& request, ::apipb::AddPathResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddPathRequest, ::apipb::AddPathResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPath_, context, request, response);
}

void GobgpApi::Stub::async::AddPath(::grpc::ClientContext* context, const ::apipb::AddPathRequest* request, ::apipb::AddPathResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddPathRequest, ::apipb::AddPathResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPath_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddPath(::grpc::ClientContext* context, const ::apipb::AddPathRequest* request, ::apipb::AddPathResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPath_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::apipb::AddPathResponse>* GobgpApi::Stub::PrepareAsyncAddPathRaw(::grpc::ClientContext* context, const ::apipb::AddPathRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::apipb::AddPathResponse, ::apipb::AddPathRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPath_, context, request);
}

::grpc::ClientAsyncResponseReader< ::apipb::AddPathResponse>* GobgpApi::Stub::AsyncAddPathRaw(::grpc::ClientContext* context, const ::apipb::AddPathRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddPathRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeletePath(::grpc::ClientContext* context, const ::apipb::DeletePathRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeletePathRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeletePath_, context, request, response);
}

void GobgpApi::Stub::async::DeletePath(::grpc::ClientContext* context, const ::apipb::DeletePathRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeletePathRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePath_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeletePath(::grpc::ClientContext* context, const ::apipb::DeletePathRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePath_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeletePathRaw(::grpc::ClientContext* context, const ::apipb::DeletePathRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeletePathRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeletePath_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeletePathRaw(::grpc::ClientContext* context, const ::apipb::DeletePathRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeletePathRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListPathResponse>* GobgpApi::Stub::ListPathRaw(::grpc::ClientContext* context, const ::apipb::ListPathRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListPathResponse>::Create(channel_.get(), rpcmethod_ListPath_, context, request);
}

void GobgpApi::Stub::async::ListPath(::grpc::ClientContext* context, const ::apipb::ListPathRequest* request, ::grpc::ClientReadReactor< ::apipb::ListPathResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListPathResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListPath_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListPathResponse>* GobgpApi::Stub::AsyncListPathRaw(::grpc::ClientContext* context, const ::apipb::ListPathRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPathResponse>::Create(channel_.get(), cq, rpcmethod_ListPath_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListPathResponse>* GobgpApi::Stub::PrepareAsyncListPathRaw(::grpc::ClientContext* context, const ::apipb::ListPathRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPathResponse>::Create(channel_.get(), cq, rpcmethod_ListPath_, context, request, false, nullptr);
}

::grpc::ClientWriter< ::apipb::AddPathStreamRequest>* GobgpApi::Stub::AddPathStreamRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
  return ::grpc::internal::ClientWriterFactory< ::apipb::AddPathStreamRequest>::Create(channel_.get(), rpcmethod_AddPathStream_, context, response);
}

void GobgpApi::Stub::async::AddPathStream(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::apipb::AddPathStreamRequest>* reactor) {
  ::grpc::internal::ClientCallbackWriterFactory< ::apipb::AddPathStreamRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_AddPathStream_, context, response, reactor);
}

::grpc::ClientAsyncWriter< ::apipb::AddPathStreamRequest>* GobgpApi::Stub::AsyncAddPathStreamRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncWriterFactory< ::apipb::AddPathStreamRequest>::Create(channel_.get(), cq, rpcmethod_AddPathStream_, context, response, true, tag);
}

::grpc::ClientAsyncWriter< ::apipb::AddPathStreamRequest>* GobgpApi::Stub::PrepareAsyncAddPathStreamRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncWriterFactory< ::apipb::AddPathStreamRequest>::Create(channel_.get(), cq, rpcmethod_AddPathStream_, context, response, false, nullptr);
}

::grpc::Status GobgpApi::Stub::GetTable(::grpc::ClientContext* context, const ::apipb::GetTableRequest& request, ::apipb::GetTableResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::GetTableRequest, ::apipb::GetTableResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetTable_, context, request, response);
}

void GobgpApi::Stub::async::GetTable(::grpc::ClientContext* context, const ::apipb::GetTableRequest* request, ::apipb::GetTableResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::GetTableRequest, ::apipb::GetTableResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTable_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::GetTable(::grpc::ClientContext* context, const ::apipb::GetTableRequest* request, ::apipb::GetTableResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetTable_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::apipb::GetTableResponse>* GobgpApi::Stub::PrepareAsyncGetTableRaw(::grpc::ClientContext* context, const ::apipb::GetTableRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::apipb::GetTableResponse, ::apipb::GetTableRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetTable_, context, request);
}

::grpc::ClientAsyncResponseReader< ::apipb::GetTableResponse>* GobgpApi::Stub::AsyncGetTableRaw(::grpc::ClientContext* context, const ::apipb::GetTableRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetTableRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddVrf(::grpc::ClientContext* context, const ::apipb::AddVrfRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddVrf_, context, request, response);
}

void GobgpApi::Stub::async::AddVrf(::grpc::ClientContext* context, const ::apipb::AddVrfRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddVrf_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddVrf(::grpc::ClientContext* context, const ::apipb::AddVrfRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddVrf_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddVrfRaw(::grpc::ClientContext* context, const ::apipb::AddVrfRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddVrfRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddVrf_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddVrfRaw(::grpc::ClientContext* context, const ::apipb::AddVrfRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddVrfRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeleteVrf(::grpc::ClientContext* context, const ::apipb::DeleteVrfRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteVrf_, context, request, response);
}

void GobgpApi::Stub::async::DeleteVrf(::grpc::ClientContext* context, const ::apipb::DeleteVrfRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteVrf_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteVrf(::grpc::ClientContext* context, const ::apipb::DeleteVrfRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteVrf_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteVrfRaw(::grpc::ClientContext* context, const ::apipb::DeleteVrfRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteVrfRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteVrf_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteVrfRaw(::grpc::ClientContext* context, const ::apipb::DeleteVrfRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteVrfRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListVrfResponse>* GobgpApi::Stub::ListVrfRaw(::grpc::ClientContext* context, const ::apipb::ListVrfRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListVrfResponse>::Create(channel_.get(), rpcmethod_ListVrf_, context, request);
}

void GobgpApi::Stub::async::ListVrf(::grpc::ClientContext* context, const ::apipb::ListVrfRequest* request, ::grpc::ClientReadReactor< ::apipb::ListVrfResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListVrfResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListVrf_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListVrfResponse>* GobgpApi::Stub::AsyncListVrfRaw(::grpc::ClientContext* context, const ::apipb::ListVrfRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListVrfResponse>::Create(channel_.get(), cq, rpcmethod_ListVrf_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListVrfResponse>* GobgpApi::Stub::PrepareAsyncListVrfRaw(::grpc::ClientContext* context, const ::apipb::ListVrfRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListVrfResponse>::Create(channel_.get(), cq, rpcmethod_ListVrf_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::AddPolicy(::grpc::ClientContext* context, const ::apipb::AddPolicyRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddPolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPolicy_, context, request, response);
}

void GobgpApi::Stub::async::AddPolicy(::grpc::ClientContext* context, const ::apipb::AddPolicyRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddPolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPolicy_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddPolicy(::grpc::ClientContext* context, const ::apipb::AddPolicyRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPolicy_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddPolicyRaw(::grpc::ClientContext* context, const ::apipb::AddPolicyRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddPolicyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPolicy_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddPolicyRaw(::grpc::ClientContext* context, const ::apipb::AddPolicyRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddPolicyRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeletePolicy(::grpc::ClientContext* context, const ::apipb::DeletePolicyRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeletePolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeletePolicy_, context, request, response);
}

void GobgpApi::Stub::async::DeletePolicy(::grpc::ClientContext* context, const ::apipb::DeletePolicyRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeletePolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePolicy_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeletePolicy(::grpc::ClientContext* context, const ::apipb::DeletePolicyRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePolicy_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeletePolicyRaw(::grpc::ClientContext* context, const ::apipb::DeletePolicyRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeletePolicyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeletePolicy_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeletePolicyRaw(::grpc::ClientContext* context, const ::apipb::DeletePolicyRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeletePolicyRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListPolicyResponse>* GobgpApi::Stub::ListPolicyRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListPolicyResponse>::Create(channel_.get(), rpcmethod_ListPolicy_, context, request);
}

void GobgpApi::Stub::async::ListPolicy(::grpc::ClientContext* context, const ::apipb::ListPolicyRequest* request, ::grpc::ClientReadReactor< ::apipb::ListPolicyResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListPolicyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListPolicy_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListPolicyResponse>* GobgpApi::Stub::AsyncListPolicyRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPolicyResponse>::Create(channel_.get(), cq, rpcmethod_ListPolicy_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListPolicyResponse>* GobgpApi::Stub::PrepareAsyncListPolicyRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPolicyResponse>::Create(channel_.get(), cq, rpcmethod_ListPolicy_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::SetPolicies(::grpc::ClientContext* context, const ::apipb::SetPoliciesRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::SetPoliciesRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetPolicies_, context, request, response);
}

void GobgpApi::Stub::async::SetPolicies(::grpc::ClientContext* context, const ::apipb::SetPoliciesRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::SetPoliciesRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetPolicies_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::SetPolicies(::grpc::ClientContext* context, const ::apipb::SetPoliciesRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetPolicies_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncSetPoliciesRaw(::grpc::ClientContext* context, const ::apipb::SetPoliciesRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::SetPoliciesRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetPolicies_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncSetPoliciesRaw(::grpc::ClientContext* context, const ::apipb::SetPoliciesRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSetPoliciesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddDefinedSet(::grpc::ClientContext* context, const ::apipb::AddDefinedSetRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddDefinedSet_, context, request, response);
}

void GobgpApi::Stub::async::AddDefinedSet(::grpc::ClientContext* context, const ::apipb::AddDefinedSetRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddDefinedSet_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddDefinedSet(::grpc::ClientContext* context, const ::apipb::AddDefinedSetRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddDefinedSet_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::AddDefinedSetRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddDefinedSetRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddDefinedSet_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::AddDefinedSetRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddDefinedSetRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeleteDefinedSet(::grpc::ClientContext* context, const ::apipb::DeleteDefinedSetRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteDefinedSet_, context, request, response);
}

void GobgpApi::Stub::async::DeleteDefinedSet(::grpc::ClientContext* context, const ::apipb::DeleteDefinedSetRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteDefinedSet_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteDefinedSet(::grpc::ClientContext* context, const ::apipb::DeleteDefinedSetRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteDefinedSet_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::DeleteDefinedSetRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteDefinedSetRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteDefinedSet_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::DeleteDefinedSetRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteDefinedSetRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListDefinedSetResponse>* GobgpApi::Stub::ListDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::ListDefinedSetRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListDefinedSetResponse>::Create(channel_.get(), rpcmethod_ListDefinedSet_, context, request);
}

void GobgpApi::Stub::async::ListDefinedSet(::grpc::ClientContext* context, const ::apipb::ListDefinedSetRequest* request, ::grpc::ClientReadReactor< ::apipb::ListDefinedSetResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListDefinedSetResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListDefinedSet_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListDefinedSetResponse>* GobgpApi::Stub::AsyncListDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::ListDefinedSetRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListDefinedSetResponse>::Create(channel_.get(), cq, rpcmethod_ListDefinedSet_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListDefinedSetResponse>* GobgpApi::Stub::PrepareAsyncListDefinedSetRaw(::grpc::ClientContext* context, const ::apipb::ListDefinedSetRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListDefinedSetResponse>::Create(channel_.get(), cq, rpcmethod_ListDefinedSet_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::AddStatement(::grpc::ClientContext* context, const ::apipb::AddStatementRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddStatement_, context, request, response);
}

void GobgpApi::Stub::async::AddStatement(::grpc::ClientContext* context, const ::apipb::AddStatementRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddStatement_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddStatement(::grpc::ClientContext* context, const ::apipb::AddStatementRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddStatement_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddStatementRaw(::grpc::ClientContext* context, const ::apipb::AddStatementRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddStatementRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddStatement_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddStatementRaw(::grpc::ClientContext* context, const ::apipb::AddStatementRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddStatementRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeleteStatement(::grpc::ClientContext* context, const ::apipb::DeleteStatementRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteStatement_, context, request, response);
}

void GobgpApi::Stub::async::DeleteStatement(::grpc::ClientContext* context, const ::apipb::DeleteStatementRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteStatement_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteStatement(::grpc::ClientContext* context, const ::apipb::DeleteStatementRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteStatement_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteStatementRaw(::grpc::ClientContext* context, const ::apipb::DeleteStatementRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteStatementRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteStatement_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteStatementRaw(::grpc::ClientContext* context, const ::apipb::DeleteStatementRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteStatementRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListStatementResponse>* GobgpApi::Stub::ListStatementRaw(::grpc::ClientContext* context, const ::apipb::ListStatementRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListStatementResponse>::Create(channel_.get(), rpcmethod_ListStatement_, context, request);
}

void GobgpApi::Stub::async::ListStatement(::grpc::ClientContext* context, const ::apipb::ListStatementRequest* request, ::grpc::ClientReadReactor< ::apipb::ListStatementResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListStatementResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListStatement_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListStatementResponse>* GobgpApi::Stub::AsyncListStatementRaw(::grpc::ClientContext* context, const ::apipb::ListStatementRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListStatementResponse>::Create(channel_.get(), cq, rpcmethod_ListStatement_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListStatementResponse>* GobgpApi::Stub::PrepareAsyncListStatementRaw(::grpc::ClientContext* context, const ::apipb::ListStatementRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListStatementResponse>::Create(channel_.get(), cq, rpcmethod_ListStatement_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::AddPolicyAssignment(::grpc::ClientContext* context, const ::apipb::AddPolicyAssignmentRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddPolicyAssignment_, context, request, response);
}

void GobgpApi::Stub::async::AddPolicyAssignment(::grpc::ClientContext* context, const ::apipb::AddPolicyAssignmentRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPolicyAssignment_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddPolicyAssignment(::grpc::ClientContext* context, const ::apipb::AddPolicyAssignmentRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddPolicyAssignment_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::AddPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddPolicyAssignmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddPolicyAssignment_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::AddPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddPolicyAssignmentRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeletePolicyAssignment(::grpc::ClientContext* context, const ::apipb::DeletePolicyAssignmentRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeletePolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeletePolicyAssignment_, context, request, response);
}

void GobgpApi::Stub::async::DeletePolicyAssignment(::grpc::ClientContext* context, const ::apipb::DeletePolicyAssignmentRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeletePolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePolicyAssignment_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeletePolicyAssignment(::grpc::ClientContext* context, const ::apipb::DeletePolicyAssignmentRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeletePolicyAssignment_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeletePolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::DeletePolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeletePolicyAssignmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeletePolicyAssignment_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeletePolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::DeletePolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeletePolicyAssignmentRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListPolicyAssignmentResponse>* GobgpApi::Stub::ListPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyAssignmentRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListPolicyAssignmentResponse>::Create(channel_.get(), rpcmethod_ListPolicyAssignment_, context, request);
}

void GobgpApi::Stub::async::ListPolicyAssignment(::grpc::ClientContext* context, const ::apipb::ListPolicyAssignmentRequest* request, ::grpc::ClientReadReactor< ::apipb::ListPolicyAssignmentResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListPolicyAssignmentResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListPolicyAssignment_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListPolicyAssignmentResponse>* GobgpApi::Stub::AsyncListPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPolicyAssignmentResponse>::Create(channel_.get(), cq, rpcmethod_ListPolicyAssignment_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListPolicyAssignmentResponse>* GobgpApi::Stub::PrepareAsyncListPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::ListPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListPolicyAssignmentResponse>::Create(channel_.get(), cq, rpcmethod_ListPolicyAssignment_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::SetPolicyAssignment(::grpc::ClientContext* context, const ::apipb::SetPolicyAssignmentRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::SetPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetPolicyAssignment_, context, request, response);
}

void GobgpApi::Stub::async::SetPolicyAssignment(::grpc::ClientContext* context, const ::apipb::SetPolicyAssignmentRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::SetPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetPolicyAssignment_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::SetPolicyAssignment(::grpc::ClientContext* context, const ::apipb::SetPolicyAssignmentRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetPolicyAssignment_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncSetPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::SetPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::SetPolicyAssignmentRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetPolicyAssignment_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncSetPolicyAssignmentRaw(::grpc::ClientContext* context, const ::apipb::SetPolicyAssignmentRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSetPolicyAssignmentRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddRpki(::grpc::ClientContext* context, const ::apipb::AddRpkiRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddRpki_, context, request, response);
}

void GobgpApi::Stub::async::AddRpki(::grpc::ClientContext* context, const ::apipb::AddRpkiRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddRpki_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddRpki(::grpc::ClientContext* context, const ::apipb::AddRpkiRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddRpki_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddRpkiRaw(::grpc::ClientContext* context, const ::apipb::AddRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddRpkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddRpki_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddRpkiRaw(::grpc::ClientContext* context, const ::apipb::AddRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddRpkiRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeleteRpki(::grpc::ClientContext* context, const ::apipb::DeleteRpkiRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteRpki_, context, request, response);
}

void GobgpApi::Stub::async::DeleteRpki(::grpc::ClientContext* context, const ::apipb::DeleteRpkiRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteRpki_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteRpki(::grpc::ClientContext* context, const ::apipb::DeleteRpkiRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteRpki_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteRpkiRaw(::grpc::ClientContext* context, const ::apipb::DeleteRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteRpkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteRpki_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteRpkiRaw(::grpc::ClientContext* context, const ::apipb::DeleteRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteRpkiRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListRpkiResponse>* GobgpApi::Stub::ListRpkiRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListRpkiResponse>::Create(channel_.get(), rpcmethod_ListRpki_, context, request);
}

void GobgpApi::Stub::async::ListRpki(::grpc::ClientContext* context, const ::apipb::ListRpkiRequest* request, ::grpc::ClientReadReactor< ::apipb::ListRpkiResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListRpkiResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListRpki_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListRpkiResponse>* GobgpApi::Stub::AsyncListRpkiRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListRpkiResponse>::Create(channel_.get(), cq, rpcmethod_ListRpki_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListRpkiResponse>* GobgpApi::Stub::PrepareAsyncListRpkiRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListRpkiResponse>::Create(channel_.get(), cq, rpcmethod_ListRpki_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::EnableRpki(::grpc::ClientContext* context, const ::apipb::EnableRpkiRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::EnableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EnableRpki_, context, request, response);
}

void GobgpApi::Stub::async::EnableRpki(::grpc::ClientContext* context, const ::apipb::EnableRpkiRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::EnableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableRpki_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::EnableRpki(::grpc::ClientContext* context, const ::apipb::EnableRpkiRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableRpki_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncEnableRpkiRaw(::grpc::ClientContext* context, const ::apipb::EnableRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::EnableRpkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EnableRpki_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncEnableRpkiRaw(::grpc::ClientContext* context, const ::apipb::EnableRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncEnableRpkiRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DisableRpki(::grpc::ClientContext* context, const ::apipb::DisableRpkiRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DisableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DisableRpki_, context, request, response);
}

void GobgpApi::Stub::async::DisableRpki(::grpc::ClientContext* context, const ::apipb::DisableRpkiRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DisableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisableRpki_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DisableRpki(::grpc::ClientContext* context, const ::apipb::DisableRpkiRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisableRpki_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDisableRpkiRaw(::grpc::ClientContext* context, const ::apipb::DisableRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DisableRpkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DisableRpki_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDisableRpkiRaw(::grpc::ClientContext* context, const ::apipb::DisableRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDisableRpkiRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::ResetRpki(::grpc::ClientContext* context, const ::apipb::ResetRpkiRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::ResetRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ResetRpki_, context, request, response);
}

void GobgpApi::Stub::async::ResetRpki(::grpc::ClientContext* context, const ::apipb::ResetRpkiRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::ResetRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ResetRpki_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::ResetRpki(::grpc::ClientContext* context, const ::apipb::ResetRpkiRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ResetRpki_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncResetRpkiRaw(::grpc::ClientContext* context, const ::apipb::ResetRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::ResetRpkiRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ResetRpki_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncResetRpkiRaw(::grpc::ClientContext* context, const ::apipb::ResetRpkiRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncResetRpkiRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListRpkiTableResponse>* GobgpApi::Stub::ListRpkiTableRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiTableRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListRpkiTableResponse>::Create(channel_.get(), rpcmethod_ListRpkiTable_, context, request);
}

void GobgpApi::Stub::async::ListRpkiTable(::grpc::ClientContext* context, const ::apipb::ListRpkiTableRequest* request, ::grpc::ClientReadReactor< ::apipb::ListRpkiTableResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListRpkiTableResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListRpkiTable_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListRpkiTableResponse>* GobgpApi::Stub::AsyncListRpkiTableRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiTableRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListRpkiTableResponse>::Create(channel_.get(), cq, rpcmethod_ListRpkiTable_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListRpkiTableResponse>* GobgpApi::Stub::PrepareAsyncListRpkiTableRaw(::grpc::ClientContext* context, const ::apipb::ListRpkiTableRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListRpkiTableResponse>::Create(channel_.get(), cq, rpcmethod_ListRpkiTable_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::EnableZebra(::grpc::ClientContext* context, const ::apipb::EnableZebraRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::EnableZebraRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EnableZebra_, context, request, response);
}

void GobgpApi::Stub::async::EnableZebra(::grpc::ClientContext* context, const ::apipb::EnableZebraRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::EnableZebraRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableZebra_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::EnableZebra(::grpc::ClientContext* context, const ::apipb::EnableZebraRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableZebra_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncEnableZebraRaw(::grpc::ClientContext* context, const ::apipb::EnableZebraRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::EnableZebraRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EnableZebra_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncEnableZebraRaw(::grpc::ClientContext* context, const ::apipb::EnableZebraRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncEnableZebraRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::EnableMrt(::grpc::ClientContext* context, const ::apipb::EnableMrtRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::EnableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EnableMrt_, context, request, response);
}

void GobgpApi::Stub::async::EnableMrt(::grpc::ClientContext* context, const ::apipb::EnableMrtRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::EnableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableMrt_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::EnableMrt(::grpc::ClientContext* context, const ::apipb::EnableMrtRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EnableMrt_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncEnableMrtRaw(::grpc::ClientContext* context, const ::apipb::EnableMrtRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::EnableMrtRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EnableMrt_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncEnableMrtRaw(::grpc::ClientContext* context, const ::apipb::EnableMrtRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncEnableMrtRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DisableMrt(::grpc::ClientContext* context, const ::apipb::DisableMrtRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DisableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DisableMrt_, context, request, response);
}

void GobgpApi::Stub::async::DisableMrt(::grpc::ClientContext* context, const ::apipb::DisableMrtRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DisableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisableMrt_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DisableMrt(::grpc::ClientContext* context, const ::apipb::DisableMrtRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DisableMrt_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDisableMrtRaw(::grpc::ClientContext* context, const ::apipb::DisableMrtRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DisableMrtRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DisableMrt_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDisableMrtRaw(::grpc::ClientContext* context, const ::apipb::DisableMrtRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDisableMrtRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::AddBmp(::grpc::ClientContext* context, const ::apipb::AddBmpRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::AddBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddBmp_, context, request, response);
}

void GobgpApi::Stub::async::AddBmp(::grpc::ClientContext* context, const ::apipb::AddBmpRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::AddBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddBmp_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::AddBmp(::grpc::ClientContext* context, const ::apipb::AddBmpRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddBmp_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncAddBmpRaw(::grpc::ClientContext* context, const ::apipb::AddBmpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::AddBmpRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddBmp_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncAddBmpRaw(::grpc::ClientContext* context, const ::apipb::AddBmpRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddBmpRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status GobgpApi::Stub::DeleteBmp(::grpc::ClientContext* context, const ::apipb::DeleteBmpRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::DeleteBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteBmp_, context, request, response);
}

void GobgpApi::Stub::async::DeleteBmp(::grpc::ClientContext* context, const ::apipb::DeleteBmpRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::DeleteBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteBmp_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::DeleteBmp(::grpc::ClientContext* context, const ::apipb::DeleteBmpRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteBmp_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncDeleteBmpRaw(::grpc::ClientContext* context, const ::apipb::DeleteBmpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::DeleteBmpRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteBmp_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncDeleteBmpRaw(::grpc::ClientContext* context, const ::apipb::DeleteBmpRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteBmpRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::ClientReader< ::apipb::ListBmpResponse>* GobgpApi::Stub::ListBmpRaw(::grpc::ClientContext* context, const ::apipb::ListBmpRequest& request) {
  return ::grpc::internal::ClientReaderFactory< ::apipb::ListBmpResponse>::Create(channel_.get(), rpcmethod_ListBmp_, context, request);
}

void GobgpApi::Stub::async::ListBmp(::grpc::ClientContext* context, const ::apipb::ListBmpRequest* request, ::grpc::ClientReadReactor< ::apipb::ListBmpResponse>* reactor) {
  ::grpc::internal::ClientCallbackReaderFactory< ::apipb::ListBmpResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_ListBmp_, context, request, reactor);
}

::grpc::ClientAsyncReader< ::apipb::ListBmpResponse>* GobgpApi::Stub::AsyncListBmpRaw(::grpc::ClientContext* context, const ::apipb::ListBmpRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListBmpResponse>::Create(channel_.get(), cq, rpcmethod_ListBmp_, context, request, true, tag);
}

::grpc::ClientAsyncReader< ::apipb::ListBmpResponse>* GobgpApi::Stub::PrepareAsyncListBmpRaw(::grpc::ClientContext* context, const ::apipb::ListBmpRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncReaderFactory< ::apipb::ListBmpResponse>::Create(channel_.get(), cq, rpcmethod_ListBmp_, context, request, false, nullptr);
}

::grpc::Status GobgpApi::Stub::SetLogLevel(::grpc::ClientContext* context, const ::apipb::SetLogLevelRequest& request, ::google::protobuf::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::apipb::SetLogLevelRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SetLogLevel_, context, request, response);
}

void GobgpApi::Stub::async::SetLogLevel(::grpc::ClientContext* context, const ::apipb::SetLogLevelRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::apipb::SetLogLevelRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetLogLevel_, context, request, response, std::move(f));
}

void GobgpApi::Stub::async::SetLogLevel(::grpc::ClientContext* context, const ::apipb::SetLogLevelRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SetLogLevel_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::PrepareAsyncSetLogLevelRaw(::grpc::ClientContext* context, const ::apipb::SetLogLevelRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::apipb::SetLogLevelRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SetLogLevel_, context, request);
}

::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* GobgpApi::Stub::AsyncSetLogLevelRaw(::grpc::ClientContext* context, const ::apipb::SetLogLevelRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSetLogLevelRaw(context, request, cq);
  result->StartCall();
  return result;
}

GobgpApi::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::StartBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::StartBgpRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->StartBgp(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::StopBgpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::StopBgpRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->StopBgp(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[2],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::GetBgpRequest, ::apipb::GetBgpResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::GetBgpRequest* req,
             ::apipb::GetBgpResponse* resp) {
               return service->GetBgp(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[3],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::WatchEventRequest, ::apipb::WatchEventResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::WatchEventRequest* req,
             ::grpc::ServerWriter<::apipb::WatchEventResponse>* writer) {
               return service->WatchEvent(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[4],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddPeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddPeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[5],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeletePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeletePeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeletePeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[6],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListPeerRequest, ::apipb::ListPeerResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListPeerRequest* req,
             ::grpc::ServerWriter<::apipb::ListPeerResponse>* writer) {
               return service->ListPeer(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[7],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::UpdatePeerRequest, ::apipb::UpdatePeerResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::UpdatePeerRequest* req,
             ::apipb::UpdatePeerResponse* resp) {
               return service->UpdatePeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[8],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::ResetPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ResetPeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->ResetPeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[9],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::ShutdownPeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ShutdownPeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->ShutdownPeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[10],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::EnablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::EnablePeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->EnablePeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[11],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DisablePeerRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DisablePeerRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DisablePeer(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[12],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddPeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddPeerGroupRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddPeerGroup(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[13],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeletePeerGroupRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeletePeerGroupRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeletePeerGroup(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[14],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListPeerGroupRequest, ::apipb::ListPeerGroupResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListPeerGroupRequest* req,
             ::grpc::ServerWriter<::apipb::ListPeerGroupResponse>* writer) {
               return service->ListPeerGroup(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[15],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::UpdatePeerGroupRequest, ::apipb::UpdatePeerGroupResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::UpdatePeerGroupRequest* req,
             ::apipb::UpdatePeerGroupResponse* resp) {
               return service->UpdatePeerGroup(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[16],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddDynamicNeighborRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddDynamicNeighbor(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[17],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListDynamicNeighborRequest, ::apipb::ListDynamicNeighborResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListDynamicNeighborRequest* req,
             ::grpc::ServerWriter<::apipb::ListDynamicNeighborResponse>* writer) {
               return service->ListDynamicNeighbor(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[18],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteDynamicNeighborRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteDynamicNeighborRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteDynamicNeighbor(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[19],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddPathRequest, ::apipb::AddPathResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddPathRequest* req,
             ::apipb::AddPathResponse* resp) {
               return service->AddPath(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[20],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeletePathRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeletePathRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeletePath(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[21],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListPathRequest, ::apipb::ListPathResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListPathRequest* req,
             ::grpc::ServerWriter<::apipb::ListPathResponse>* writer) {
               return service->ListPath(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[22],
      ::grpc::internal::RpcMethod::CLIENT_STREAMING,
      new ::grpc::internal::ClientStreamingHandler< GobgpApi::Service, ::apipb::AddPathStreamRequest, ::google::protobuf::Empty>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             ::grpc::ServerReader<::apipb::AddPathStreamRequest>* reader,
             ::google::protobuf::Empty* resp) {
               return service->AddPathStream(ctx, reader, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[23],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::GetTableRequest, ::apipb::GetTableResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::GetTableRequest* req,
             ::apipb::GetTableResponse* resp) {
               return service->GetTable(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[24],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddVrfRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddVrf(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[25],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteVrfRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteVrfRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteVrf(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[26],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListVrfRequest, ::apipb::ListVrfResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListVrfRequest* req,
             ::grpc::ServerWriter<::apipb::ListVrfResponse>* writer) {
               return service->ListVrf(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[27],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddPolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddPolicyRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddPolicy(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[28],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeletePolicyRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeletePolicyRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeletePolicy(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[29],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListPolicyRequest, ::apipb::ListPolicyResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListPolicyRequest* req,
             ::grpc::ServerWriter<::apipb::ListPolicyResponse>* writer) {
               return service->ListPolicy(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[30],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::SetPoliciesRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::SetPoliciesRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->SetPolicies(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[31],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddDefinedSetRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddDefinedSet(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[32],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteDefinedSetRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteDefinedSetRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteDefinedSet(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[33],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListDefinedSetRequest, ::apipb::ListDefinedSetResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListDefinedSetRequest* req,
             ::grpc::ServerWriter<::apipb::ListDefinedSetResponse>* writer) {
               return service->ListDefinedSet(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[34],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddStatementRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddStatement(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[35],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteStatementRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteStatementRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteStatement(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[36],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListStatementRequest, ::apipb::ListStatementResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListStatementRequest* req,
             ::grpc::ServerWriter<::apipb::ListStatementResponse>* writer) {
               return service->ListStatement(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[37],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddPolicyAssignmentRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddPolicyAssignment(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[38],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeletePolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeletePolicyAssignmentRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeletePolicyAssignment(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[39],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListPolicyAssignmentRequest, ::apipb::ListPolicyAssignmentResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListPolicyAssignmentRequest* req,
             ::grpc::ServerWriter<::apipb::ListPolicyAssignmentResponse>* writer) {
               return service->ListPolicyAssignment(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[40],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::SetPolicyAssignmentRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::SetPolicyAssignmentRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->SetPolicyAssignment(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[41],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddRpkiRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddRpki(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[42],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteRpkiRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteRpki(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[43],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListRpkiRequest, ::apipb::ListRpkiResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListRpkiRequest* req,
             ::grpc::ServerWriter<::apipb::ListRpkiResponse>* writer) {
               return service->ListRpki(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[44],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::EnableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::EnableRpkiRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->EnableRpki(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[45],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DisableRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DisableRpkiRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DisableRpki(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[46],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::ResetRpkiRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ResetRpkiRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->ResetRpki(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[47],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListRpkiTableRequest, ::apipb::ListRpkiTableResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListRpkiTableRequest* req,
             ::grpc::ServerWriter<::apipb::ListRpkiTableResponse>* writer) {
               return service->ListRpkiTable(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[48],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::EnableZebraRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::EnableZebraRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->EnableZebra(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[49],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::EnableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::EnableMrtRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->EnableMrt(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[50],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DisableMrtRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DisableMrtRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DisableMrt(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[51],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::AddBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::AddBmpRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->AddBmp(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[52],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::DeleteBmpRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::DeleteBmpRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->DeleteBmp(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[53],
      ::grpc::internal::RpcMethod::SERVER_STREAMING,
      new ::grpc::internal::ServerStreamingHandler< GobgpApi::Service, ::apipb::ListBmpRequest, ::apipb::ListBmpResponse>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::ListBmpRequest* req,
             ::grpc::ServerWriter<::apipb::ListBmpResponse>* writer) {
               return service->ListBmp(ctx, req, writer);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      GobgpApi_method_names[54],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< GobgpApi::Service, ::apipb::SetLogLevelRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](GobgpApi::Service* service,
             ::grpc::ServerContext* ctx,
             const ::apipb::SetLogLevelRequest* req,
             ::google::protobuf::Empty* resp) {
               return service->SetLogLevel(ctx, req, resp);
             }, this)));
}

GobgpApi::Service::~Service() {
}

::grpc::Status GobgpApi::Service::StartBgp(::grpc::ServerContext* context, const ::apipb::StartBgpRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::StopBgp(::grpc::ServerContext* context, const ::apipb::StopBgpRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::GetBgp(::grpc::ServerContext* context, const ::apipb::GetBgpRequest* request, ::apipb::GetBgpResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::WatchEvent(::grpc::ServerContext* context, const ::apipb::WatchEventRequest* request, ::grpc::ServerWriter< ::apipb::WatchEventResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPeer(::grpc::ServerContext* context, const ::apipb::AddPeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeletePeer(::grpc::ServerContext* context, const ::apipb::DeletePeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListPeer(::grpc::ServerContext* context, const ::apipb::ListPeerRequest* request, ::grpc::ServerWriter< ::apipb::ListPeerResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::UpdatePeer(::grpc::ServerContext* context, const ::apipb::UpdatePeerRequest* request, ::apipb::UpdatePeerResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ResetPeer(::grpc::ServerContext* context, const ::apipb::ResetPeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ShutdownPeer(::grpc::ServerContext* context, const ::apipb::ShutdownPeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::EnablePeer(::grpc::ServerContext* context, const ::apipb::EnablePeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DisablePeer(::grpc::ServerContext* context, const ::apipb::DisablePeerRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPeerGroup(::grpc::ServerContext* context, const ::apipb::AddPeerGroupRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeletePeerGroup(::grpc::ServerContext* context, const ::apipb::DeletePeerGroupRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListPeerGroup(::grpc::ServerContext* context, const ::apipb::ListPeerGroupRequest* request, ::grpc::ServerWriter< ::apipb::ListPeerGroupResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::UpdatePeerGroup(::grpc::ServerContext* context, const ::apipb::UpdatePeerGroupRequest* request, ::apipb::UpdatePeerGroupResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddDynamicNeighbor(::grpc::ServerContext* context, const ::apipb::AddDynamicNeighborRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListDynamicNeighbor(::grpc::ServerContext* context, const ::apipb::ListDynamicNeighborRequest* request, ::grpc::ServerWriter< ::apipb::ListDynamicNeighborResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteDynamicNeighbor(::grpc::ServerContext* context, const ::apipb::DeleteDynamicNeighborRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPath(::grpc::ServerContext* context, const ::apipb::AddPathRequest* request, ::apipb::AddPathResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeletePath(::grpc::ServerContext* context, const ::apipb::DeletePathRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListPath(::grpc::ServerContext* context, const ::apipb::ListPathRequest* request, ::grpc::ServerWriter< ::apipb::ListPathResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPathStream(::grpc::ServerContext* context, ::grpc::ServerReader< ::apipb::AddPathStreamRequest>* reader, ::google::protobuf::Empty* response) {
  (void) context;
  (void) reader;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::GetTable(::grpc::ServerContext* context, const ::apipb::GetTableRequest* request, ::apipb::GetTableResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddVrf(::grpc::ServerContext* context, const ::apipb::AddVrfRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteVrf(::grpc::ServerContext* context, const ::apipb::DeleteVrfRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListVrf(::grpc::ServerContext* context, const ::apipb::ListVrfRequest* request, ::grpc::ServerWriter< ::apipb::ListVrfResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPolicy(::grpc::ServerContext* context, const ::apipb::AddPolicyRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeletePolicy(::grpc::ServerContext* context, const ::apipb::DeletePolicyRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListPolicy(::grpc::ServerContext* context, const ::apipb::ListPolicyRequest* request, ::grpc::ServerWriter< ::apipb::ListPolicyResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::SetPolicies(::grpc::ServerContext* context, const ::apipb::SetPoliciesRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddDefinedSet(::grpc::ServerContext* context, const ::apipb::AddDefinedSetRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteDefinedSet(::grpc::ServerContext* context, const ::apipb::DeleteDefinedSetRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListDefinedSet(::grpc::ServerContext* context, const ::apipb::ListDefinedSetRequest* request, ::grpc::ServerWriter< ::apipb::ListDefinedSetResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddStatement(::grpc::ServerContext* context, const ::apipb::AddStatementRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteStatement(::grpc::ServerContext* context, const ::apipb::DeleteStatementRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListStatement(::grpc::ServerContext* context, const ::apipb::ListStatementRequest* request, ::grpc::ServerWriter< ::apipb::ListStatementResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddPolicyAssignment(::grpc::ServerContext* context, const ::apipb::AddPolicyAssignmentRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeletePolicyAssignment(::grpc::ServerContext* context, const ::apipb::DeletePolicyAssignmentRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListPolicyAssignment(::grpc::ServerContext* context, const ::apipb::ListPolicyAssignmentRequest* request, ::grpc::ServerWriter< ::apipb::ListPolicyAssignmentResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::SetPolicyAssignment(::grpc::ServerContext* context, const ::apipb::SetPolicyAssignmentRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddRpki(::grpc::ServerContext* context, const ::apipb::AddRpkiRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteRpki(::grpc::ServerContext* context, const ::apipb::DeleteRpkiRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListRpki(::grpc::ServerContext* context, const ::apipb::ListRpkiRequest* request, ::grpc::ServerWriter< ::apipb::ListRpkiResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::EnableRpki(::grpc::ServerContext* context, const ::apipb::EnableRpkiRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DisableRpki(::grpc::ServerContext* context, const ::apipb::DisableRpkiRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ResetRpki(::grpc::ServerContext* context, const ::apipb::ResetRpkiRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListRpkiTable(::grpc::ServerContext* context, const ::apipb::ListRpkiTableRequest* request, ::grpc::ServerWriter< ::apipb::ListRpkiTableResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::EnableZebra(::grpc::ServerContext* context, const ::apipb::EnableZebraRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::EnableMrt(::grpc::ServerContext* context, const ::apipb::EnableMrtRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DisableMrt(::grpc::ServerContext* context, const ::apipb::DisableMrtRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::AddBmp(::grpc::ServerContext* context, const ::apipb::AddBmpRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::DeleteBmp(::grpc::ServerContext* context, const ::apipb::DeleteBmpRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::ListBmp(::grpc::ServerContext* context, const ::apipb::ListBmpRequest* request, ::grpc::ServerWriter< ::apipb::ListBmpResponse>* writer) {
  (void) context;
  (void) request;
  (void) writer;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status GobgpApi::Service::SetLogLevel(::grpc::ServerContext* context, const ::apipb::SetLogLevelRequest* request, ::google::protobuf::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


}  // namespace apipb
#include <grpcpp/ports_undef.inc>

