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

#include "demo.pb.h"
#include "demo.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>
namespace oteldemo {

static const char* CartService_method_names[] = {
  "/oteldemo.CartService/AddItem",
  "/oteldemo.CartService/GetCart",
  "/oteldemo.CartService/EmptyCart",
};

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

CartService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_AddItem_(CartService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetCart_(CartService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_EmptyCart_(CartService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status CartService::Stub::AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::oteldemo::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::AddItemRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddItem_, context, request, response);
}

void CartService::Stub::async::AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::AddItemRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddItem_, context, request, response, std::move(f));
}

void CartService::Stub::async::AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddItem_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* CartService::Stub::PrepareAsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Empty, ::oteldemo::AddItemRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddItem_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* CartService::Stub::AsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncAddItemRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CartService::Stub::GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::oteldemo::Cart* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::GetCartRequest, ::oteldemo::Cart, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetCart_, context, request, response);
}

void CartService::Stub::async::GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::GetCartRequest, ::oteldemo::Cart, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetCart_, context, request, response, std::move(f));
}

void CartService::Stub::async::GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetCart_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>* CartService::Stub::PrepareAsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Cart, ::oteldemo::GetCartRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetCart_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>* CartService::Stub::AsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetCartRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CartService::Stub::EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::oteldemo::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::EmptyCartRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_EmptyCart_, context, request, response);
}

void CartService::Stub::async::EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::EmptyCartRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EmptyCart_, context, request, response, std::move(f));
}

void CartService::Stub::async::EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_EmptyCart_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* CartService::Stub::PrepareAsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Empty, ::oteldemo::EmptyCartRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_EmptyCart_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* CartService::Stub::AsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncEmptyCartRaw(context, request, cq);
  result->StartCall();
  return result;
}

CartService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CartService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CartService::Service, ::oteldemo::AddItemRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CartService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::AddItemRequest* req,
             ::oteldemo::Empty* resp) {
               return service->AddItem(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CartService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CartService::Service, ::oteldemo::GetCartRequest, ::oteldemo::Cart, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CartService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::GetCartRequest* req,
             ::oteldemo::Cart* resp) {
               return service->GetCart(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CartService_method_names[2],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CartService::Service, ::oteldemo::EmptyCartRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CartService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::EmptyCartRequest* req,
             ::oteldemo::Empty* resp) {
               return service->EmptyCart(ctx, req, resp);
             }, this)));
}

CartService::Service::~Service() {
}

::grpc::Status CartService::Service::AddItem(::grpc::ServerContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status CartService::Service::GetCart(::grpc::ServerContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status CartService::Service::EmptyCart(::grpc::ServerContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* RecommendationService_method_names[] = {
  "/oteldemo.RecommendationService/ListRecommendations",
};

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

RecommendationService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_ListRecommendations_(RecommendationService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status RecommendationService::Stub::ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::oteldemo::ListRecommendationsResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ListRecommendations_, context, request, response);
}

void RecommendationService::Stub::async::ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListRecommendations_, context, request, response, std::move(f));
}

void RecommendationService::Stub::async::ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListRecommendations_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>* RecommendationService::Stub::PrepareAsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::ListRecommendationsResponse, ::oteldemo::ListRecommendationsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ListRecommendations_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>* RecommendationService::Stub::AsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncListRecommendationsRaw(context, request, cq);
  result->StartCall();
  return result;
}

RecommendationService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      RecommendationService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< RecommendationService::Service, ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](RecommendationService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::ListRecommendationsRequest* req,
             ::oteldemo::ListRecommendationsResponse* resp) {
               return service->ListRecommendations(ctx, req, resp);
             }, this)));
}

RecommendationService::Service::~Service() {
}

::grpc::Status RecommendationService::Service::ListRecommendations(::grpc::ServerContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* ProductCatalogService_method_names[] = {
  "/oteldemo.ProductCatalogService/ListProducts",
  "/oteldemo.ProductCatalogService/GetProduct",
  "/oteldemo.ProductCatalogService/SearchProducts",
};

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

ProductCatalogService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_ListProducts_(ProductCatalogService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_GetProduct_(ProductCatalogService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_SearchProducts_(ProductCatalogService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status ProductCatalogService::Stub::ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::ListProductsResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::Empty, ::oteldemo::ListProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ListProducts_, context, request, response);
}

void ProductCatalogService::Stub::async::ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::Empty, ::oteldemo::ListProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListProducts_, context, request, response, std::move(f));
}

void ProductCatalogService::Stub::async::ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListProducts_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>* ProductCatalogService::Stub::PrepareAsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::ListProductsResponse, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ListProducts_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>* ProductCatalogService::Stub::AsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncListProductsRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status ProductCatalogService::Stub::GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::oteldemo::Product* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::GetProductRequest, ::oteldemo::Product, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetProduct_, context, request, response);
}

void ProductCatalogService::Stub::async::GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::GetProductRequest, ::oteldemo::Product, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetProduct_, context, request, response, std::move(f));
}

void ProductCatalogService::Stub::async::GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetProduct_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Product>* ProductCatalogService::Stub::PrepareAsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Product, ::oteldemo::GetProductRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetProduct_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Product>* ProductCatalogService::Stub::AsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetProductRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status ProductCatalogService::Stub::SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::oteldemo::SearchProductsResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SearchProducts_, context, request, response);
}

void ProductCatalogService::Stub::async::SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SearchProducts_, context, request, response, std::move(f));
}

void ProductCatalogService::Stub::async::SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SearchProducts_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>* ProductCatalogService::Stub::PrepareAsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::SearchProductsResponse, ::oteldemo::SearchProductsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SearchProducts_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>* ProductCatalogService::Stub::AsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSearchProductsRaw(context, request, cq);
  result->StartCall();
  return result;
}

ProductCatalogService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      ProductCatalogService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< ProductCatalogService::Service, ::oteldemo::Empty, ::oteldemo::ListProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](ProductCatalogService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::Empty* req,
             ::oteldemo::ListProductsResponse* resp) {
               return service->ListProducts(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      ProductCatalogService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< ProductCatalogService::Service, ::oteldemo::GetProductRequest, ::oteldemo::Product, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](ProductCatalogService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::GetProductRequest* req,
             ::oteldemo::Product* resp) {
               return service->GetProduct(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      ProductCatalogService_method_names[2],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< ProductCatalogService::Service, ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](ProductCatalogService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::SearchProductsRequest* req,
             ::oteldemo::SearchProductsResponse* resp) {
               return service->SearchProducts(ctx, req, resp);
             }, this)));
}

ProductCatalogService::Service::~Service() {
}

::grpc::Status ProductCatalogService::Service::ListProducts(::grpc::ServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status ProductCatalogService::Service::GetProduct(::grpc::ServerContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status ProductCatalogService::Service::SearchProducts(::grpc::ServerContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* ShippingService_method_names[] = {
  "/oteldemo.ShippingService/GetQuote",
  "/oteldemo.ShippingService/ShipOrder",
};

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

ShippingService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_GetQuote_(ShippingService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ShipOrder_(ShippingService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status ShippingService::Stub::GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::oteldemo::GetQuoteResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetQuote_, context, request, response);
}

void ShippingService::Stub::async::GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetQuote_, context, request, response, std::move(f));
}

void ShippingService::Stub::async::GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetQuote_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>* ShippingService::Stub::PrepareAsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::GetQuoteResponse, ::oteldemo::GetQuoteRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetQuote_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>* ShippingService::Stub::AsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetQuoteRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status ShippingService::Stub::ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::oteldemo::ShipOrderResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ShipOrder_, context, request, response);
}

void ShippingService::Stub::async::ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ShipOrder_, context, request, response, std::move(f));
}

void ShippingService::Stub::async::ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ShipOrder_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>* ShippingService::Stub::PrepareAsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::ShipOrderResponse, ::oteldemo::ShipOrderRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ShipOrder_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>* ShippingService::Stub::AsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncShipOrderRaw(context, request, cq);
  result->StartCall();
  return result;
}

ShippingService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      ShippingService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< ShippingService::Service, ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](ShippingService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::GetQuoteRequest* req,
             ::oteldemo::GetQuoteResponse* resp) {
               return service->GetQuote(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      ShippingService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< ShippingService::Service, ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](ShippingService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::ShipOrderRequest* req,
             ::oteldemo::ShipOrderResponse* resp) {
               return service->ShipOrder(ctx, req, resp);
             }, this)));
}

ShippingService::Service::~Service() {
}

::grpc::Status ShippingService::Service::GetQuote(::grpc::ServerContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status ShippingService::Service::ShipOrder(::grpc::ServerContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* CurrencyService_method_names[] = {
  "/oteldemo.CurrencyService/GetSupportedCurrencies",
  "/oteldemo.CurrencyService/Convert",
};

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

CurrencyService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_GetSupportedCurrencies_(CurrencyService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_Convert_(CurrencyService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status CurrencyService::Stub::GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::GetSupportedCurrenciesResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetSupportedCurrencies_, context, request, response);
}

void CurrencyService::Stub::async::GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSupportedCurrencies_, context, request, response, std::move(f));
}

void CurrencyService::Stub::async::GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetSupportedCurrencies_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>* CurrencyService::Stub::PrepareAsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::GetSupportedCurrenciesResponse, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetSupportedCurrencies_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>* CurrencyService::Stub::AsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetSupportedCurrenciesRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status CurrencyService::Stub::Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::oteldemo::Money* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Convert_, context, request, response);
}

void CurrencyService::Stub::async::Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Convert_, context, request, response, std::move(f));
}

void CurrencyService::Stub::async::Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Convert_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Money>* CurrencyService::Stub::PrepareAsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Money, ::oteldemo::CurrencyConversionRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Convert_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Money>* CurrencyService::Stub::AsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncConvertRaw(context, request, cq);
  result->StartCall();
  return result;
}

CurrencyService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CurrencyService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CurrencyService::Service, ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CurrencyService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::Empty* req,
             ::oteldemo::GetSupportedCurrenciesResponse* resp) {
               return service->GetSupportedCurrencies(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CurrencyService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CurrencyService::Service, ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CurrencyService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::CurrencyConversionRequest* req,
             ::oteldemo::Money* resp) {
               return service->Convert(ctx, req, resp);
             }, this)));
}

CurrencyService::Service::~Service() {
}

::grpc::Status CurrencyService::Service::GetSupportedCurrencies(::grpc::ServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status CurrencyService::Service::Convert(::grpc::ServerContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* PaymentService_method_names[] = {
  "/oteldemo.PaymentService/Charge",
};

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

PaymentService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_Charge_(PaymentService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status PaymentService::Stub::Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::oteldemo::ChargeResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_Charge_, context, request, response);
}

void PaymentService::Stub::async::Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Charge_, context, request, response, std::move(f));
}

void PaymentService::Stub::async::Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_Charge_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>* PaymentService::Stub::PrepareAsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::ChargeResponse, ::oteldemo::ChargeRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_Charge_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>* PaymentService::Stub::AsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncChargeRaw(context, request, cq);
  result->StartCall();
  return result;
}

PaymentService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      PaymentService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< PaymentService::Service, ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](PaymentService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::ChargeRequest* req,
             ::oteldemo::ChargeResponse* resp) {
               return service->Charge(ctx, req, resp);
             }, this)));
}

PaymentService::Service::~Service() {
}

::grpc::Status PaymentService::Service::Charge(::grpc::ServerContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* EmailService_method_names[] = {
  "/oteldemo.EmailService/SendOrderConfirmation",
};

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

EmailService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_SendOrderConfirmation_(EmailService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status EmailService::Stub::SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::oteldemo::Empty* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendOrderConfirmation_, context, request, response);
}

void EmailService::Stub::async::SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendOrderConfirmation_, context, request, response, std::move(f));
}

void EmailService::Stub::async::SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendOrderConfirmation_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* EmailService::Stub::PrepareAsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::Empty, ::oteldemo::SendOrderConfirmationRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendOrderConfirmation_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* EmailService::Stub::AsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncSendOrderConfirmationRaw(context, request, cq);
  result->StartCall();
  return result;
}

EmailService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      EmailService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< EmailService::Service, ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](EmailService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::SendOrderConfirmationRequest* req,
             ::oteldemo::Empty* resp) {
               return service->SendOrderConfirmation(ctx, req, resp);
             }, this)));
}

EmailService::Service::~Service() {
}

::grpc::Status EmailService::Service::SendOrderConfirmation(::grpc::ServerContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* CheckoutService_method_names[] = {
  "/oteldemo.CheckoutService/PlaceOrder",
};

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

CheckoutService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_PlaceOrder_(CheckoutService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status CheckoutService::Stub::PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::oteldemo::PlaceOrderResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PlaceOrder_, context, request, response);
}

void CheckoutService::Stub::async::PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PlaceOrder_, context, request, response, std::move(f));
}

void CheckoutService::Stub::async::PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PlaceOrder_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>* CheckoutService::Stub::PrepareAsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::PlaceOrderResponse, ::oteldemo::PlaceOrderRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PlaceOrder_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>* CheckoutService::Stub::AsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncPlaceOrderRaw(context, request, cq);
  result->StartCall();
  return result;
}

CheckoutService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      CheckoutService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< CheckoutService::Service, ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](CheckoutService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::PlaceOrderRequest* req,
             ::oteldemo::PlaceOrderResponse* resp) {
               return service->PlaceOrder(ctx, req, resp);
             }, this)));
}

CheckoutService::Service::~Service() {
}

::grpc::Status CheckoutService::Service::PlaceOrder(::grpc::ServerContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* AdService_method_names[] = {
  "/oteldemo.AdService/GetAds",
};

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

AdService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_GetAds_(AdService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status AdService::Stub::GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::oteldemo::AdResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::AdRequest, ::oteldemo::AdResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetAds_, context, request, response);
}

void AdService::Stub::async::GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::AdRequest, ::oteldemo::AdResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetAds_, context, request, response, std::move(f));
}

void AdService::Stub::async::GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetAds_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>* AdService::Stub::PrepareAsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::AdResponse, ::oteldemo::AdRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetAds_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>* AdService::Stub::AsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetAdsRaw(context, request, cq);
  result->StartCall();
  return result;
}

AdService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      AdService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< AdService::Service, ::oteldemo::AdRequest, ::oteldemo::AdResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](AdService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::AdRequest* req,
             ::oteldemo::AdResponse* resp) {
               return service->GetAds(ctx, req, resp);
             }, this)));
}

AdService::Service::~Service() {
}

::grpc::Status AdService::Service::GetAds(::grpc::ServerContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


static const char* FeatureFlagService_method_names[] = {
  "/oteldemo.FeatureFlagService/GetFlag",
  "/oteldemo.FeatureFlagService/CreateFlag",
  "/oteldemo.FeatureFlagService/UpdateFlag",
  "/oteldemo.FeatureFlagService/ListFlags",
  "/oteldemo.FeatureFlagService/DeleteFlag",
};

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

FeatureFlagService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
  : channel_(channel), rpcmethod_GetFlag_(FeatureFlagService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_CreateFlag_(FeatureFlagService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_UpdateFlag_(FeatureFlagService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_ListFlags_(FeatureFlagService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  , rpcmethod_DeleteFlag_(FeatureFlagService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
  {}

::grpc::Status FeatureFlagService::Stub::GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::oteldemo::GetFlagResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetFlag_, context, request, response);
}

void FeatureFlagService::Stub::async::GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetFlag_, context, request, response, std::move(f));
}

void FeatureFlagService::Stub::async::GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetFlag_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>* FeatureFlagService::Stub::PrepareAsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::GetFlagResponse, ::oteldemo::GetFlagRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetFlag_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>* FeatureFlagService::Stub::AsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncGetFlagRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status FeatureFlagService::Stub::CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::oteldemo::CreateFlagResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_CreateFlag_, context, request, response);
}

void FeatureFlagService::Stub::async::CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CreateFlag_, context, request, response, std::move(f));
}

void FeatureFlagService::Stub::async::CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_CreateFlag_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>* FeatureFlagService::Stub::PrepareAsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::CreateFlagResponse, ::oteldemo::CreateFlagRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_CreateFlag_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>* FeatureFlagService::Stub::AsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncCreateFlagRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status FeatureFlagService::Stub::UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::oteldemo::UpdateFlagResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_UpdateFlag_, context, request, response);
}

void FeatureFlagService::Stub::async::UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdateFlag_, context, request, response, std::move(f));
}

void FeatureFlagService::Stub::async::UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_UpdateFlag_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>* FeatureFlagService::Stub::PrepareAsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::UpdateFlagResponse, ::oteldemo::UpdateFlagRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_UpdateFlag_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>* FeatureFlagService::Stub::AsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncUpdateFlagRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status FeatureFlagService::Stub::ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::oteldemo::ListFlagsResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_ListFlags_, context, request, response);
}

void FeatureFlagService::Stub::async::ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListFlags_, context, request, response, std::move(f));
}

void FeatureFlagService::Stub::async::ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_ListFlags_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>* FeatureFlagService::Stub::PrepareAsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::ListFlagsResponse, ::oteldemo::ListFlagsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_ListFlags_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>* FeatureFlagService::Stub::AsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncListFlagsRaw(context, request, cq);
  result->StartCall();
  return result;
}

::grpc::Status FeatureFlagService::Stub::DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::oteldemo::DeleteFlagResponse* response) {
  return ::grpc::internal::BlockingUnaryCall< ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_DeleteFlag_, context, request, response);
}

void FeatureFlagService::Stub::async::DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, std::function<void(::grpc::Status)> f) {
  ::grpc::internal::CallbackUnaryCall< ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteFlag_, context, request, response, std::move(f));
}

void FeatureFlagService::Stub::async::DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) {
  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_DeleteFlag_, context, request, response, reactor);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>* FeatureFlagService::Stub::PrepareAsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::oteldemo::DeleteFlagResponse, ::oteldemo::DeleteFlagRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_DeleteFlag_, context, request);
}

::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>* FeatureFlagService::Stub::AsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
  auto* result =
    this->PrepareAsyncDeleteFlagRaw(context, request, cq);
  result->StartCall();
  return result;
}

FeatureFlagService::Service::Service() {
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      FeatureFlagService_method_names[0],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< FeatureFlagService::Service, ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](FeatureFlagService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::GetFlagRequest* req,
             ::oteldemo::GetFlagResponse* resp) {
               return service->GetFlag(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      FeatureFlagService_method_names[1],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< FeatureFlagService::Service, ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](FeatureFlagService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::CreateFlagRequest* req,
             ::oteldemo::CreateFlagResponse* resp) {
               return service->CreateFlag(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      FeatureFlagService_method_names[2],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< FeatureFlagService::Service, ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](FeatureFlagService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::UpdateFlagRequest* req,
             ::oteldemo::UpdateFlagResponse* resp) {
               return service->UpdateFlag(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      FeatureFlagService_method_names[3],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< FeatureFlagService::Service, ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](FeatureFlagService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::ListFlagsRequest* req,
             ::oteldemo::ListFlagsResponse* resp) {
               return service->ListFlags(ctx, req, resp);
             }, this)));
  AddMethod(new ::grpc::internal::RpcServiceMethod(
      FeatureFlagService_method_names[4],
      ::grpc::internal::RpcMethod::NORMAL_RPC,
      new ::grpc::internal::RpcMethodHandler< FeatureFlagService::Service, ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
          [](FeatureFlagService::Service* service,
             ::grpc::ServerContext* ctx,
             const ::oteldemo::DeleteFlagRequest* req,
             ::oteldemo::DeleteFlagResponse* resp) {
               return service->DeleteFlag(ctx, req, resp);
             }, this)));
}

FeatureFlagService::Service::~Service() {
}

::grpc::Status FeatureFlagService::Service::GetFlag(::grpc::ServerContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status FeatureFlagService::Service::CreateFlag(::grpc::ServerContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status FeatureFlagService::Service::UpdateFlag(::grpc::ServerContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status FeatureFlagService::Service::ListFlags(::grpc::ServerContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}

::grpc::Status FeatureFlagService::Service::DeleteFlag(::grpc::ServerContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response) {
  (void) context;
  (void) request;
  (void) response;
  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}


}  // namespace oteldemo