// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: demo.proto
// Original file comments:
// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef GRPC_demo_2eproto__INCLUDED
#define GRPC_demo_2eproto__INCLUDED

#include "demo.pb.h"

#include <functional>
#include <grpcpp/generic/async_generic_service.h>
#include <grpcpp/support/async_stream.h>
#include <grpcpp/support/async_unary_call.h>
#include <grpcpp/support/client_callback.h>
#include <grpcpp/client_context.h>
#include <grpcpp/completion_queue.h>
#include <grpcpp/support/message_allocator.h>
#include <grpcpp/support/method_handler.h>
#include <grpcpp/impl/proto_utils.h>
#include <grpcpp/impl/rpc_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/status.h>
#include <grpcpp/support/stub_options.h>
#include <grpcpp/support/sync_stream.h>

namespace oteldemo {

// -----------------Cart service-----------------
//
class CartService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.CartService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::oteldemo::Empty* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> AsyncAddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(AsyncAddItemRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> PrepareAsyncAddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(PrepareAsyncAddItemRaw(context, request, cq));
    }
    virtual ::grpc::Status GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::oteldemo::Cart* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>> AsyncGetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>>(AsyncGetCartRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>> PrepareAsyncGetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>>(PrepareAsyncGetCartRaw(context, request, cq));
    }
    virtual ::grpc::Status EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::oteldemo::Empty* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> AsyncEmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(AsyncEmptyCartRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> PrepareAsyncEmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(PrepareAsyncEmptyCartRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) = 0;
      virtual void AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) = 0;
      virtual void EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* AsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* PrepareAsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>* AsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Cart>* PrepareAsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* AsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* PrepareAsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::oteldemo::Empty* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> AsyncAddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(AsyncAddItemRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> PrepareAsyncAddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(PrepareAsyncAddItemRaw(context, request, cq));
    }
    ::grpc::Status GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::oteldemo::Cart* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>> AsyncGetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>>(AsyncGetCartRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>> PrepareAsyncGetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>>(PrepareAsyncGetCartRaw(context, request, cq));
    }
    ::grpc::Status EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::oteldemo::Empty* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> AsyncEmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(AsyncEmptyCartRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> PrepareAsyncEmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(PrepareAsyncEmptyCartRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) override;
      void AddItem(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
      void GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, std::function<void(::grpc::Status)>) override;
      void GetCart(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response, ::grpc::ClientUnaryReactor* reactor) override;
      void EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) override;
      void EmptyCart(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* AsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* PrepareAsyncAddItemRaw(::grpc::ClientContext* context, const ::oteldemo::AddItemRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>* AsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Cart>* PrepareAsyncGetCartRaw(::grpc::ClientContext* context, const ::oteldemo::GetCartRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* AsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* PrepareAsyncEmptyCartRaw(::grpc::ClientContext* context, const ::oteldemo::EmptyCartRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_AddItem_;
    const ::grpc::internal::RpcMethod rpcmethod_GetCart_;
    const ::grpc::internal::RpcMethod rpcmethod_EmptyCart_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status AddItem(::grpc::ServerContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response);
    virtual ::grpc::Status GetCart(::grpc::ServerContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response);
    virtual ::grpc::Status EmptyCart(::grpc::ServerContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_AddItem() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestAddItem(::grpc::ServerContext* context, ::oteldemo::AddItemRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetCart() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetCart(::grpc::ServerContext* context, ::oteldemo::GetCartRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Cart>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_EmptyCart() {
      ::grpc::Service::MarkMethodAsync(2);
    }
    ~WithAsyncMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestEmptyCart(::grpc::ServerContext* context, ::oteldemo::EmptyCartRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_AddItem<WithAsyncMethod_GetCart<WithAsyncMethod_EmptyCart<Service > > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_AddItem() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::AddItemRequest, ::oteldemo::Empty>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::AddItemRequest* request, ::oteldemo::Empty* response) { return this->AddItem(context, request, response); }));}
    void SetMessageAllocatorFor_AddItem(
        ::grpc::MessageAllocator< ::oteldemo::AddItemRequest, ::oteldemo::Empty>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::AddItemRequest, ::oteldemo::Empty>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* AddItem(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetCart() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetCartRequest, ::oteldemo::Cart>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::GetCartRequest* request, ::oteldemo::Cart* response) { return this->GetCart(context, request, response); }));}
    void SetMessageAllocatorFor_GetCart(
        ::grpc::MessageAllocator< ::oteldemo::GetCartRequest, ::oteldemo::Cart>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetCartRequest, ::oteldemo::Cart>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetCart(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_EmptyCart() {
      ::grpc::Service::MarkMethodCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::EmptyCartRequest, ::oteldemo::Empty>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::EmptyCartRequest* request, ::oteldemo::Empty* response) { return this->EmptyCart(context, request, response); }));}
    void SetMessageAllocatorFor_EmptyCart(
        ::grpc::MessageAllocator< ::oteldemo::EmptyCartRequest, ::oteldemo::Empty>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::EmptyCartRequest, ::oteldemo::Empty>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* EmptyCart(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_AddItem<WithCallbackMethod_GetCart<WithCallbackMethod_EmptyCart<Service > > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_AddItem() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetCart() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_EmptyCart() {
      ::grpc::Service::MarkMethodGeneric(2);
    }
    ~WithGenericMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_AddItem() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestAddItem(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetCart() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetCart(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_EmptyCart() {
      ::grpc::Service::MarkMethodRaw(2);
    }
    ~WithRawMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestEmptyCart(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_AddItem() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddItem(context, request, response); }));
    }
    ~WithRawCallbackMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* AddItem(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetCart() {
      ::grpc::Service::MarkMethodRawCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetCart(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetCart(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_EmptyCart() {
      ::grpc::Service::MarkMethodRawCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->EmptyCart(context, request, response); }));
    }
    ~WithRawCallbackMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* EmptyCart(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_AddItem : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_AddItem() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::AddItemRequest, ::oteldemo::Empty>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::AddItemRequest, ::oteldemo::Empty>* streamer) {
                       return this->StreamedAddItem(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_AddItem() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status AddItem(::grpc::ServerContext* /*context*/, const ::oteldemo::AddItemRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedAddItem(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::AddItemRequest,::oteldemo::Empty>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetCart() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::GetCartRequest, ::oteldemo::Cart>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::GetCartRequest, ::oteldemo::Cart>* streamer) {
                       return this->StreamedGetCart(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetCart(::grpc::ServerContext* /*context*/, const ::oteldemo::GetCartRequest* /*request*/, ::oteldemo::Cart* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetCart(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::GetCartRequest,::oteldemo::Cart>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_EmptyCart : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_EmptyCart() {
      ::grpc::Service::MarkMethodStreamed(2,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::EmptyCartRequest, ::oteldemo::Empty>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::EmptyCartRequest, ::oteldemo::Empty>* streamer) {
                       return this->StreamedEmptyCart(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_EmptyCart() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status EmptyCart(::grpc::ServerContext* /*context*/, const ::oteldemo::EmptyCartRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedEmptyCart(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::EmptyCartRequest,::oteldemo::Empty>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_AddItem<WithStreamedUnaryMethod_GetCart<WithStreamedUnaryMethod_EmptyCart<Service > > > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_AddItem<WithStreamedUnaryMethod_GetCart<WithStreamedUnaryMethod_EmptyCart<Service > > > StreamedService;
};

// ---------------Recommendation service----------
//
class RecommendationService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.RecommendationService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::oteldemo::ListRecommendationsResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>> AsyncListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>>(AsyncListRecommendationsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>> PrepareAsyncListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>>(PrepareAsyncListRecommendationsRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>* AsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListRecommendationsResponse>* PrepareAsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::oteldemo::ListRecommendationsResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>> AsyncListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>>(AsyncListRecommendationsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>> PrepareAsyncListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>>(PrepareAsyncListRecommendationsRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, std::function<void(::grpc::Status)>) override;
      void ListRecommendations(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>* AsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListRecommendationsResponse>* PrepareAsyncListRecommendationsRaw(::grpc::ClientContext* context, const ::oteldemo::ListRecommendationsRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_ListRecommendations_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status ListRecommendations(::grpc::ServerContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListRecommendations(::grpc::ServerContext* context, ::oteldemo::ListRecommendationsRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::ListRecommendationsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_ListRecommendations<Service > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::ListRecommendationsRequest* request, ::oteldemo::ListRecommendationsResponse* response) { return this->ListRecommendations(context, request, response); }));}
    void SetMessageAllocatorFor_ListRecommendations(
        ::grpc::MessageAllocator< ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListRecommendations(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_ListRecommendations<Service > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListRecommendations(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ListRecommendations(context, request, response); }));
    }
    ~WithRawCallbackMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListRecommendations(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_ListRecommendations : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_ListRecommendations() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::ListRecommendationsRequest, ::oteldemo::ListRecommendationsResponse>* streamer) {
                       return this->StreamedListRecommendations(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_ListRecommendations() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status ListRecommendations(::grpc::ServerContext* /*context*/, const ::oteldemo::ListRecommendationsRequest* /*request*/, ::oteldemo::ListRecommendationsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedListRecommendations(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::ListRecommendationsRequest,::oteldemo::ListRecommendationsResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_ListRecommendations<Service > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_ListRecommendations<Service > StreamedService;
};

// ---------------Product Catalog----------------
//
class ProductCatalogService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.ProductCatalogService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::ListProductsResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>> AsyncListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>>(AsyncListProductsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>> PrepareAsyncListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>>(PrepareAsyncListProductsRaw(context, request, cq));
    }
    virtual ::grpc::Status GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::oteldemo::Product* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>> AsyncGetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>>(AsyncGetProductRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>> PrepareAsyncGetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>>(PrepareAsyncGetProductRaw(context, request, cq));
    }
    virtual ::grpc::Status SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::oteldemo::SearchProductsResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>> AsyncSearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>>(AsyncSearchProductsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>> PrepareAsyncSearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>>(PrepareAsyncSearchProductsRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>* AsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListProductsResponse>* PrepareAsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>* AsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Product>* PrepareAsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>* AsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::SearchProductsResponse>* PrepareAsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::ListProductsResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>> AsyncListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>>(AsyncListProductsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>> PrepareAsyncListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>>(PrepareAsyncListProductsRaw(context, request, cq));
    }
    ::grpc::Status GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::oteldemo::Product* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>> AsyncGetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>>(AsyncGetProductRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>> PrepareAsyncGetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>>(PrepareAsyncGetProductRaw(context, request, cq));
    }
    ::grpc::Status SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::oteldemo::SearchProductsResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>> AsyncSearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>>(AsyncSearchProductsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>> PrepareAsyncSearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>>(PrepareAsyncSearchProductsRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, std::function<void(::grpc::Status)>) override;
      void ListProducts(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, std::function<void(::grpc::Status)>) override;
      void GetProduct(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response, ::grpc::ClientUnaryReactor* reactor) override;
      void SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, std::function<void(::grpc::Status)>) override;
      void SearchProducts(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>* AsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListProductsResponse>* PrepareAsyncListProductsRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>* AsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Product>* PrepareAsyncGetProductRaw(::grpc::ClientContext* context, const ::oteldemo::GetProductRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>* AsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::SearchProductsResponse>* PrepareAsyncSearchProductsRaw(::grpc::ClientContext* context, const ::oteldemo::SearchProductsRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_ListProducts_;
    const ::grpc::internal::RpcMethod rpcmethod_GetProduct_;
    const ::grpc::internal::RpcMethod rpcmethod_SearchProducts_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status ListProducts(::grpc::ServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response);
    virtual ::grpc::Status GetProduct(::grpc::ServerContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response);
    virtual ::grpc::Status SearchProducts(::grpc::ServerContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_ListProducts() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListProducts(::grpc::ServerContext* context, ::oteldemo::Empty* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::ListProductsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetProduct() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetProduct(::grpc::ServerContext* context, ::oteldemo::GetProductRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Product>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_SearchProducts() {
      ::grpc::Service::MarkMethodAsync(2);
    }
    ~WithAsyncMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestSearchProducts(::grpc::ServerContext* context, ::oteldemo::SearchProductsRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::SearchProductsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_ListProducts<WithAsyncMethod_GetProduct<WithAsyncMethod_SearchProducts<Service > > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_ListProducts() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::Empty, ::oteldemo::ListProductsResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::ListProductsResponse* response) { return this->ListProducts(context, request, response); }));}
    void SetMessageAllocatorFor_ListProducts(
        ::grpc::MessageAllocator< ::oteldemo::Empty, ::oteldemo::ListProductsResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::Empty, ::oteldemo::ListProductsResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListProducts(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetProduct() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetProductRequest, ::oteldemo::Product>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::GetProductRequest* request, ::oteldemo::Product* response) { return this->GetProduct(context, request, response); }));}
    void SetMessageAllocatorFor_GetProduct(
        ::grpc::MessageAllocator< ::oteldemo::GetProductRequest, ::oteldemo::Product>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetProductRequest, ::oteldemo::Product>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetProduct(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_SearchProducts() {
      ::grpc::Service::MarkMethodCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::SearchProductsRequest* request, ::oteldemo::SearchProductsResponse* response) { return this->SearchProducts(context, request, response); }));}
    void SetMessageAllocatorFor_SearchProducts(
        ::grpc::MessageAllocator< ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* SearchProducts(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_ListProducts<WithCallbackMethod_GetProduct<WithCallbackMethod_SearchProducts<Service > > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_ListProducts() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetProduct() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_SearchProducts() {
      ::grpc::Service::MarkMethodGeneric(2);
    }
    ~WithGenericMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_ListProducts() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListProducts(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetProduct() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetProduct(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_SearchProducts() {
      ::grpc::Service::MarkMethodRaw(2);
    }
    ~WithRawMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestSearchProducts(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_ListProducts() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ListProducts(context, request, response); }));
    }
    ~WithRawCallbackMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListProducts(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetProduct() {
      ::grpc::Service::MarkMethodRawCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetProduct(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetProduct(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_SearchProducts() {
      ::grpc::Service::MarkMethodRawCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SearchProducts(context, request, response); }));
    }
    ~WithRawCallbackMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* SearchProducts(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_ListProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_ListProducts() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::Empty, ::oteldemo::ListProductsResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::Empty, ::oteldemo::ListProductsResponse>* streamer) {
                       return this->StreamedListProducts(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_ListProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status ListProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::ListProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedListProducts(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::Empty,::oteldemo::ListProductsResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetProduct : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetProduct() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::GetProductRequest, ::oteldemo::Product>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::GetProductRequest, ::oteldemo::Product>* streamer) {
                       return this->StreamedGetProduct(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetProduct() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetProduct(::grpc::ServerContext* /*context*/, const ::oteldemo::GetProductRequest* /*request*/, ::oteldemo::Product* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetProduct(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::GetProductRequest,::oteldemo::Product>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_SearchProducts : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_SearchProducts() {
      ::grpc::Service::MarkMethodStreamed(2,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::SearchProductsRequest, ::oteldemo::SearchProductsResponse>* streamer) {
                       return this->StreamedSearchProducts(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_SearchProducts() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status SearchProducts(::grpc::ServerContext* /*context*/, const ::oteldemo::SearchProductsRequest* /*request*/, ::oteldemo::SearchProductsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedSearchProducts(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::SearchProductsRequest,::oteldemo::SearchProductsResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_ListProducts<WithStreamedUnaryMethod_GetProduct<WithStreamedUnaryMethod_SearchProducts<Service > > > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_ListProducts<WithStreamedUnaryMethod_GetProduct<WithStreamedUnaryMethod_SearchProducts<Service > > > StreamedService;
};

// ---------------Shipping Service----------
//
class ShippingService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.ShippingService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::oteldemo::GetQuoteResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>> AsyncGetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>>(AsyncGetQuoteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>> PrepareAsyncGetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>>(PrepareAsyncGetQuoteRaw(context, request, cq));
    }
    virtual ::grpc::Status ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::oteldemo::ShipOrderResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>> AsyncShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>>(AsyncShipOrderRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>> PrepareAsyncShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>>(PrepareAsyncShipOrderRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>* AsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetQuoteResponse>* PrepareAsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>* AsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ShipOrderResponse>* PrepareAsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::oteldemo::GetQuoteResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>> AsyncGetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>>(AsyncGetQuoteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>> PrepareAsyncGetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>>(PrepareAsyncGetQuoteRaw(context, request, cq));
    }
    ::grpc::Status ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::oteldemo::ShipOrderResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>> AsyncShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>>(AsyncShipOrderRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>> PrepareAsyncShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>>(PrepareAsyncShipOrderRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, std::function<void(::grpc::Status)>) override;
      void GetQuote(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, std::function<void(::grpc::Status)>) override;
      void ShipOrder(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>* AsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetQuoteResponse>* PrepareAsyncGetQuoteRaw(::grpc::ClientContext* context, const ::oteldemo::GetQuoteRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>* AsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ShipOrderResponse>* PrepareAsyncShipOrderRaw(::grpc::ClientContext* context, const ::oteldemo::ShipOrderRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_GetQuote_;
    const ::grpc::internal::RpcMethod rpcmethod_ShipOrder_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status GetQuote(::grpc::ServerContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response);
    virtual ::grpc::Status ShipOrder(::grpc::ServerContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetQuote() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetQuote(::grpc::ServerContext* context, ::oteldemo::GetQuoteRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::GetQuoteResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_ShipOrder() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestShipOrder(::grpc::ServerContext* context, ::oteldemo::ShipOrderRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::ShipOrderResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_GetQuote<WithAsyncMethod_ShipOrder<Service > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetQuote() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::GetQuoteRequest* request, ::oteldemo::GetQuoteResponse* response) { return this->GetQuote(context, request, response); }));}
    void SetMessageAllocatorFor_GetQuote(
        ::grpc::MessageAllocator< ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetQuote(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_ShipOrder() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::ShipOrderRequest* request, ::oteldemo::ShipOrderResponse* response) { return this->ShipOrder(context, request, response); }));}
    void SetMessageAllocatorFor_ShipOrder(
        ::grpc::MessageAllocator< ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ShipOrder(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_GetQuote<WithCallbackMethod_ShipOrder<Service > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetQuote() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_ShipOrder() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetQuote() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetQuote(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_ShipOrder() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestShipOrder(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetQuote() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetQuote(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetQuote(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_ShipOrder() {
      ::grpc::Service::MarkMethodRawCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ShipOrder(context, request, response); }));
    }
    ~WithRawCallbackMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ShipOrder(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetQuote : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetQuote() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::GetQuoteRequest, ::oteldemo::GetQuoteResponse>* streamer) {
                       return this->StreamedGetQuote(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetQuote() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetQuote(::grpc::ServerContext* /*context*/, const ::oteldemo::GetQuoteRequest* /*request*/, ::oteldemo::GetQuoteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetQuote(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::GetQuoteRequest,::oteldemo::GetQuoteResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_ShipOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_ShipOrder() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::ShipOrderRequest, ::oteldemo::ShipOrderResponse>* streamer) {
                       return this->StreamedShipOrder(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_ShipOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status ShipOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::ShipOrderRequest* /*request*/, ::oteldemo::ShipOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedShipOrder(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::ShipOrderRequest,::oteldemo::ShipOrderResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_GetQuote<WithStreamedUnaryMethod_ShipOrder<Service > > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_GetQuote<WithStreamedUnaryMethod_ShipOrder<Service > > StreamedService;
};

// -----------------Currency service-----------------
//
class CurrencyService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.CurrencyService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::GetSupportedCurrenciesResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>> AsyncGetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>>(AsyncGetSupportedCurrenciesRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>> PrepareAsyncGetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>>(PrepareAsyncGetSupportedCurrenciesRaw(context, request, cq));
    }
    virtual ::grpc::Status Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::oteldemo::Money* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>> AsyncConvert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>>(AsyncConvertRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>> PrepareAsyncConvert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>>(PrepareAsyncConvertRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>* AsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetSupportedCurrenciesResponse>* PrepareAsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>* AsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Money>* PrepareAsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::oteldemo::GetSupportedCurrenciesResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>> AsyncGetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>>(AsyncGetSupportedCurrenciesRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>> PrepareAsyncGetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>>(PrepareAsyncGetSupportedCurrenciesRaw(context, request, cq));
    }
    ::grpc::Status Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::oteldemo::Money* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>> AsyncConvert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>>(AsyncConvertRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>> PrepareAsyncConvert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>>(PrepareAsyncConvertRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, std::function<void(::grpc::Status)>) override;
      void GetSupportedCurrencies(::grpc::ClientContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, std::function<void(::grpc::Status)>) override;
      void Convert(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>* AsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetSupportedCurrenciesResponse>* PrepareAsyncGetSupportedCurrenciesRaw(::grpc::ClientContext* context, const ::oteldemo::Empty& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>* AsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Money>* PrepareAsyncConvertRaw(::grpc::ClientContext* context, const ::oteldemo::CurrencyConversionRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_GetSupportedCurrencies_;
    const ::grpc::internal::RpcMethod rpcmethod_Convert_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response);
    virtual ::grpc::Status Convert(::grpc::ServerContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetSupportedCurrencies(::grpc::ServerContext* context, ::oteldemo::Empty* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::GetSupportedCurrenciesResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Convert() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestConvert(::grpc::ServerContext* context, ::oteldemo::CurrencyConversionRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Money>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_GetSupportedCurrencies<WithAsyncMethod_Convert<Service > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::Empty* request, ::oteldemo::GetSupportedCurrenciesResponse* response) { return this->GetSupportedCurrencies(context, request, response); }));}
    void SetMessageAllocatorFor_GetSupportedCurrencies(
        ::grpc::MessageAllocator< ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetSupportedCurrencies(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Convert() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::CurrencyConversionRequest* request, ::oteldemo::Money* response) { return this->Convert(context, request, response); }));}
    void SetMessageAllocatorFor_Convert(
        ::grpc::MessageAllocator< ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Convert(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_GetSupportedCurrencies<WithCallbackMethod_Convert<Service > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Convert() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetSupportedCurrencies(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Convert() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestConvert(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetSupportedCurrencies(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetSupportedCurrencies(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Convert() {
      ::grpc::Service::MarkMethodRawCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Convert(context, request, response); }));
    }
    ~WithRawCallbackMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Convert(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetSupportedCurrencies : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetSupportedCurrencies() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::Empty, ::oteldemo::GetSupportedCurrenciesResponse>* streamer) {
                       return this->StreamedGetSupportedCurrencies(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetSupportedCurrencies() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetSupportedCurrencies(::grpc::ServerContext* /*context*/, const ::oteldemo::Empty* /*request*/, ::oteldemo::GetSupportedCurrenciesResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetSupportedCurrencies(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::Empty,::oteldemo::GetSupportedCurrenciesResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Convert : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Convert() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::CurrencyConversionRequest, ::oteldemo::Money>* streamer) {
                       return this->StreamedConvert(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Convert() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Convert(::grpc::ServerContext* /*context*/, const ::oteldemo::CurrencyConversionRequest* /*request*/, ::oteldemo::Money* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedConvert(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::CurrencyConversionRequest,::oteldemo::Money>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_GetSupportedCurrencies<WithStreamedUnaryMethod_Convert<Service > > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_GetSupportedCurrencies<WithStreamedUnaryMethod_Convert<Service > > StreamedService;
};

// -------------Payment service-----------------
//
class PaymentService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.PaymentService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::oteldemo::ChargeResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>> AsyncCharge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>>(AsyncChargeRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>> PrepareAsyncCharge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>>(PrepareAsyncChargeRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>* AsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ChargeResponse>* PrepareAsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::oteldemo::ChargeResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>> AsyncCharge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>>(AsyncChargeRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>> PrepareAsyncCharge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>>(PrepareAsyncChargeRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, std::function<void(::grpc::Status)>) override;
      void Charge(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>* AsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ChargeResponse>* PrepareAsyncChargeRaw(::grpc::ClientContext* context, const ::oteldemo::ChargeRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_Charge_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status Charge(::grpc::ServerContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Charge() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCharge(::grpc::ServerContext* context, ::oteldemo::ChargeRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::ChargeResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_Charge<Service > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Charge() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::ChargeRequest* request, ::oteldemo::ChargeResponse* response) { return this->Charge(context, request, response); }));}
    void SetMessageAllocatorFor_Charge(
        ::grpc::MessageAllocator< ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Charge(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_Charge<Service > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Charge() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Charge() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCharge(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Charge() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Charge(context, request, response); }));
    }
    ~WithRawCallbackMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Charge(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Charge : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Charge() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::ChargeRequest, ::oteldemo::ChargeResponse>* streamer) {
                       return this->StreamedCharge(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Charge() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Charge(::grpc::ServerContext* /*context*/, const ::oteldemo::ChargeRequest* /*request*/, ::oteldemo::ChargeResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedCharge(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::ChargeRequest,::oteldemo::ChargeResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_Charge<Service > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_Charge<Service > StreamedService;
};

// -------------Email service-----------------
//
class EmailService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.EmailService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::oteldemo::Empty* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> AsyncSendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(AsyncSendOrderConfirmationRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>> PrepareAsyncSendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>>(PrepareAsyncSendOrderConfirmationRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) = 0;
      virtual void SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* AsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::Empty>* PrepareAsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::oteldemo::Empty* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> AsyncSendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(AsyncSendOrderConfirmationRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>> PrepareAsyncSendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>>(PrepareAsyncSendOrderConfirmationRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, std::function<void(::grpc::Status)>) override;
      void SendOrderConfirmation(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* AsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::Empty>* PrepareAsyncSendOrderConfirmationRaw(::grpc::ClientContext* context, const ::oteldemo::SendOrderConfirmationRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_SendOrderConfirmation_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestSendOrderConfirmation(::grpc::ServerContext* context, ::oteldemo::SendOrderConfirmationRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_SendOrderConfirmation<Service > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::SendOrderConfirmationRequest* request, ::oteldemo::Empty* response) { return this->SendOrderConfirmation(context, request, response); }));}
    void SetMessageAllocatorFor_SendOrderConfirmation(
        ::grpc::MessageAllocator< ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* SendOrderConfirmation(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_SendOrderConfirmation<Service > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestSendOrderConfirmation(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendOrderConfirmation(context, request, response); }));
    }
    ~WithRawCallbackMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* SendOrderConfirmation(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_SendOrderConfirmation : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_SendOrderConfirmation() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::SendOrderConfirmationRequest, ::oteldemo::Empty>* streamer) {
                       return this->StreamedSendOrderConfirmation(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_SendOrderConfirmation() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status SendOrderConfirmation(::grpc::ServerContext* /*context*/, const ::oteldemo::SendOrderConfirmationRequest* /*request*/, ::oteldemo::Empty* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedSendOrderConfirmation(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::SendOrderConfirmationRequest,::oteldemo::Empty>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_SendOrderConfirmation<Service > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_SendOrderConfirmation<Service > StreamedService;
};

// -------------Checkout service-----------------
//
class CheckoutService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.CheckoutService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::oteldemo::PlaceOrderResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>> AsyncPlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>>(AsyncPlaceOrderRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>> PrepareAsyncPlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>>(PrepareAsyncPlaceOrderRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>* AsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::PlaceOrderResponse>* PrepareAsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::oteldemo::PlaceOrderResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>> AsyncPlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>>(AsyncPlaceOrderRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>> PrepareAsyncPlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>>(PrepareAsyncPlaceOrderRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, std::function<void(::grpc::Status)>) override;
      void PlaceOrder(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>* AsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::PlaceOrderResponse>* PrepareAsyncPlaceOrderRaw(::grpc::ClientContext* context, const ::oteldemo::PlaceOrderRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_PlaceOrder_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status PlaceOrder(::grpc::ServerContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestPlaceOrder(::grpc::ServerContext* context, ::oteldemo::PlaceOrderRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::PlaceOrderResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_PlaceOrder<Service > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::PlaceOrderRequest* request, ::oteldemo::PlaceOrderResponse* response) { return this->PlaceOrder(context, request, response); }));}
    void SetMessageAllocatorFor_PlaceOrder(
        ::grpc::MessageAllocator< ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* PlaceOrder(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_PlaceOrder<Service > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestPlaceOrder(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PlaceOrder(context, request, response); }));
    }
    ~WithRawCallbackMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* PlaceOrder(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_PlaceOrder : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_PlaceOrder() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::PlaceOrderRequest, ::oteldemo::PlaceOrderResponse>* streamer) {
                       return this->StreamedPlaceOrder(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_PlaceOrder() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status PlaceOrder(::grpc::ServerContext* /*context*/, const ::oteldemo::PlaceOrderRequest* /*request*/, ::oteldemo::PlaceOrderResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedPlaceOrder(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::PlaceOrderRequest,::oteldemo::PlaceOrderResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_PlaceOrder<Service > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_PlaceOrder<Service > StreamedService;
};

// ------------Ad service------------------
//
class AdService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.AdService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::oteldemo::AdResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>> AsyncGetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>>(AsyncGetAdsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>> PrepareAsyncGetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>>(PrepareAsyncGetAdsRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>* AsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::AdResponse>* PrepareAsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::oteldemo::AdResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>> AsyncGetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>>(AsyncGetAdsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>> PrepareAsyncGetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>>(PrepareAsyncGetAdsRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, std::function<void(::grpc::Status)>) override;
      void GetAds(::grpc::ClientContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>* AsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::AdResponse>* PrepareAsyncGetAdsRaw(::grpc::ClientContext* context, const ::oteldemo::AdRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_GetAds_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status GetAds(::grpc::ServerContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetAds() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetAds(::grpc::ServerContext* context, ::oteldemo::AdRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::AdResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_GetAds<Service > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetAds() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::AdRequest, ::oteldemo::AdResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::AdRequest* request, ::oteldemo::AdResponse* response) { return this->GetAds(context, request, response); }));}
    void SetMessageAllocatorFor_GetAds(
        ::grpc::MessageAllocator< ::oteldemo::AdRequest, ::oteldemo::AdResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::AdRequest, ::oteldemo::AdResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetAds(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_GetAds<Service > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetAds() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetAds() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetAds(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetAds() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetAds(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetAds(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetAds : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetAds() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::AdRequest, ::oteldemo::AdResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::AdRequest, ::oteldemo::AdResponse>* streamer) {
                       return this->StreamedGetAds(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetAds() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetAds(::grpc::ServerContext* /*context*/, const ::oteldemo::AdRequest* /*request*/, ::oteldemo::AdResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetAds(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::AdRequest,::oteldemo::AdResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_GetAds<Service > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_GetAds<Service > StreamedService;
};

// ------------Feature flag service------------------
//
class FeatureFlagService final {
 public:
  static constexpr char const* service_full_name() {
    return "oteldemo.FeatureFlagService";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::oteldemo::GetFlagResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>> AsyncGetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>>(AsyncGetFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>> PrepareAsyncGetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>>(PrepareAsyncGetFlagRaw(context, request, cq));
    }
    virtual ::grpc::Status CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::oteldemo::CreateFlagResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>> AsyncCreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>>(AsyncCreateFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>> PrepareAsyncCreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>>(PrepareAsyncCreateFlagRaw(context, request, cq));
    }
    virtual ::grpc::Status UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::oteldemo::UpdateFlagResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>> AsyncUpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>>(AsyncUpdateFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>> PrepareAsyncUpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>>(PrepareAsyncUpdateFlagRaw(context, request, cq));
    }
    virtual ::grpc::Status ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::oteldemo::ListFlagsResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>> AsyncListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>>(AsyncListFlagsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>> PrepareAsyncListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>>(PrepareAsyncListFlagsRaw(context, request, cq));
    }
    virtual ::grpc::Status DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::oteldemo::DeleteFlagResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>> AsyncDeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>>(AsyncDeleteFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>> PrepareAsyncDeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>>(PrepareAsyncDeleteFlagRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
    };
    typedef class async_interface experimental_async_interface;
    virtual class async_interface* async() { return nullptr; }
    class async_interface* experimental_async() { return async(); }
   private:
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>* AsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::GetFlagResponse>* PrepareAsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>* AsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::CreateFlagResponse>* PrepareAsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>* AsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::UpdateFlagResponse>* PrepareAsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>* AsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::ListFlagsResponse>* PrepareAsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>* AsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::oteldemo::DeleteFlagResponse>* PrepareAsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) = 0;
  };
  class Stub final : public StubInterface {
   public:
    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
    ::grpc::Status GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::oteldemo::GetFlagResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>> AsyncGetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>>(AsyncGetFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>> PrepareAsyncGetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>>(PrepareAsyncGetFlagRaw(context, request, cq));
    }
    ::grpc::Status CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::oteldemo::CreateFlagResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>> AsyncCreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>>(AsyncCreateFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>> PrepareAsyncCreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>>(PrepareAsyncCreateFlagRaw(context, request, cq));
    }
    ::grpc::Status UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::oteldemo::UpdateFlagResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>> AsyncUpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>>(AsyncUpdateFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>> PrepareAsyncUpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>>(PrepareAsyncUpdateFlagRaw(context, request, cq));
    }
    ::grpc::Status ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::oteldemo::ListFlagsResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>> AsyncListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>>(AsyncListFlagsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>> PrepareAsyncListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>>(PrepareAsyncListFlagsRaw(context, request, cq));
    }
    ::grpc::Status DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::oteldemo::DeleteFlagResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>> AsyncDeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>>(AsyncDeleteFlagRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>> PrepareAsyncDeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>>(PrepareAsyncDeleteFlagRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, std::function<void(::grpc::Status)>) override;
      void GetFlag(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, std::function<void(::grpc::Status)>) override;
      void CreateFlag(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, std::function<void(::grpc::Status)>) override;
      void UpdateFlag(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, std::function<void(::grpc::Status)>) override;
      void ListFlags(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, std::function<void(::grpc::Status)>) override;
      void DeleteFlag(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
     private:
      friend class Stub;
      explicit async(Stub* stub): stub_(stub) { }
      Stub* stub() { return stub_; }
      Stub* stub_;
    };
    class async* async() override { return &async_stub_; }

   private:
    std::shared_ptr< ::grpc::ChannelInterface> channel_;
    class async async_stub_{this};
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>* AsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::GetFlagResponse>* PrepareAsyncGetFlagRaw(::grpc::ClientContext* context, const ::oteldemo::GetFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>* AsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::CreateFlagResponse>* PrepareAsyncCreateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::CreateFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>* AsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::UpdateFlagResponse>* PrepareAsyncUpdateFlagRaw(::grpc::ClientContext* context, const ::oteldemo::UpdateFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>* AsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::ListFlagsResponse>* PrepareAsyncListFlagsRaw(::grpc::ClientContext* context, const ::oteldemo::ListFlagsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>* AsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::oteldemo::DeleteFlagResponse>* PrepareAsyncDeleteFlagRaw(::grpc::ClientContext* context, const ::oteldemo::DeleteFlagRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_GetFlag_;
    const ::grpc::internal::RpcMethod rpcmethod_CreateFlag_;
    const ::grpc::internal::RpcMethod rpcmethod_UpdateFlag_;
    const ::grpc::internal::RpcMethod rpcmethod_ListFlags_;
    const ::grpc::internal::RpcMethod rpcmethod_DeleteFlag_;
  };
  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

  class Service : public ::grpc::Service {
   public:
    Service();
    virtual ~Service();
    virtual ::grpc::Status GetFlag(::grpc::ServerContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response);
    virtual ::grpc::Status CreateFlag(::grpc::ServerContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response);
    virtual ::grpc::Status UpdateFlag(::grpc::ServerContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response);
    virtual ::grpc::Status ListFlags(::grpc::ServerContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response);
    virtual ::grpc::Status DeleteFlag(::grpc::ServerContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_GetFlag() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetFlag(::grpc::ServerContext* context, ::oteldemo::GetFlagRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::GetFlagResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_CreateFlag() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCreateFlag(::grpc::ServerContext* context, ::oteldemo::CreateFlagRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::CreateFlagResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodAsync(2);
    }
    ~WithAsyncMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestUpdateFlag(::grpc::ServerContext* context, ::oteldemo::UpdateFlagRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::UpdateFlagResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_ListFlags() {
      ::grpc::Service::MarkMethodAsync(3);
    }
    ~WithAsyncMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListFlags(::grpc::ServerContext* context, ::oteldemo::ListFlagsRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::ListFlagsResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodAsync(4);
    }
    ~WithAsyncMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestDeleteFlag(::grpc::ServerContext* context, ::oteldemo::DeleteFlagRequest* request, ::grpc::ServerAsyncResponseWriter< ::oteldemo::DeleteFlagResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_GetFlag<WithAsyncMethod_CreateFlag<WithAsyncMethod_UpdateFlag<WithAsyncMethod_ListFlags<WithAsyncMethod_DeleteFlag<Service > > > > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_GetFlag() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::GetFlagRequest* request, ::oteldemo::GetFlagResponse* response) { return this->GetFlag(context, request, response); }));}
    void SetMessageAllocatorFor_GetFlag(
        ::grpc::MessageAllocator< ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_CreateFlag() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::CreateFlagRequest* request, ::oteldemo::CreateFlagResponse* response) { return this->CreateFlag(context, request, response); }));}
    void SetMessageAllocatorFor_CreateFlag(
        ::grpc::MessageAllocator< ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* CreateFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::UpdateFlagRequest* request, ::oteldemo::UpdateFlagResponse* response) { return this->UpdateFlag(context, request, response); }));}
    void SetMessageAllocatorFor_UpdateFlag(
        ::grpc::MessageAllocator< ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* UpdateFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_ListFlags() {
      ::grpc::Service::MarkMethodCallback(3,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::ListFlagsRequest* request, ::oteldemo::ListFlagsResponse* response) { return this->ListFlags(context, request, response); }));}
    void SetMessageAllocatorFor_ListFlags(
        ::grpc::MessageAllocator< ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListFlags(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodCallback(4,
          new ::grpc::internal::CallbackUnaryHandler< ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::oteldemo::DeleteFlagRequest* request, ::oteldemo::DeleteFlagResponse* response) { return this->DeleteFlag(context, request, response); }));}
    void SetMessageAllocatorFor_DeleteFlag(
        ::grpc::MessageAllocator< ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* DeleteFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_GetFlag<WithCallbackMethod_CreateFlag<WithCallbackMethod_UpdateFlag<WithCallbackMethod_ListFlags<WithCallbackMethod_DeleteFlag<Service > > > > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_GetFlag() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_CreateFlag() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodGeneric(2);
    }
    ~WithGenericMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_ListFlags() {
      ::grpc::Service::MarkMethodGeneric(3);
    }
    ~WithGenericMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodGeneric(4);
    }
    ~WithGenericMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_GetFlag() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGetFlag(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_CreateFlag() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCreateFlag(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodRaw(2);
    }
    ~WithRawMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestUpdateFlag(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_ListFlags() {
      ::grpc::Service::MarkMethodRaw(3);
    }
    ~WithRawMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestListFlags(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodRaw(4);
    }
    ~WithRawMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestDeleteFlag(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_GetFlag() {
      ::grpc::Service::MarkMethodRawCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetFlag(context, request, response); }));
    }
    ~WithRawCallbackMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* GetFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_CreateFlag() {
      ::grpc::Service::MarkMethodRawCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CreateFlag(context, request, response); }));
    }
    ~WithRawCallbackMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* CreateFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodRawCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->UpdateFlag(context, request, response); }));
    }
    ~WithRawCallbackMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* UpdateFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_ListFlags() {
      ::grpc::Service::MarkMethodRawCallback(3,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->ListFlags(context, request, response); }));
    }
    ~WithRawCallbackMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* ListFlags(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodRawCallback(4,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->DeleteFlag(context, request, response); }));
    }
    ~WithRawCallbackMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* DeleteFlag(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_GetFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_GetFlag() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::GetFlagRequest, ::oteldemo::GetFlagResponse>* streamer) {
                       return this->StreamedGetFlag(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_GetFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status GetFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::GetFlagRequest* /*request*/, ::oteldemo::GetFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGetFlag(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::GetFlagRequest,::oteldemo::GetFlagResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_CreateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_CreateFlag() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::CreateFlagRequest, ::oteldemo::CreateFlagResponse>* streamer) {
                       return this->StreamedCreateFlag(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_CreateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status CreateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::CreateFlagRequest* /*request*/, ::oteldemo::CreateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedCreateFlag(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::CreateFlagRequest,::oteldemo::CreateFlagResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_UpdateFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_UpdateFlag() {
      ::grpc::Service::MarkMethodStreamed(2,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::UpdateFlagRequest, ::oteldemo::UpdateFlagResponse>* streamer) {
                       return this->StreamedUpdateFlag(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_UpdateFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status UpdateFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::UpdateFlagRequest* /*request*/, ::oteldemo::UpdateFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedUpdateFlag(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::UpdateFlagRequest,::oteldemo::UpdateFlagResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_ListFlags : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_ListFlags() {
      ::grpc::Service::MarkMethodStreamed(3,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::ListFlagsRequest, ::oteldemo::ListFlagsResponse>* streamer) {
                       return this->StreamedListFlags(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_ListFlags() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status ListFlags(::grpc::ServerContext* /*context*/, const ::oteldemo::ListFlagsRequest* /*request*/, ::oteldemo::ListFlagsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedListFlags(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::ListFlagsRequest,::oteldemo::ListFlagsResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_DeleteFlag : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_DeleteFlag() {
      ::grpc::Service::MarkMethodStreamed(4,
        new ::grpc::internal::StreamedUnaryHandler<
          ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::oteldemo::DeleteFlagRequest, ::oteldemo::DeleteFlagResponse>* streamer) {
                       return this->StreamedDeleteFlag(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_DeleteFlag() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status DeleteFlag(::grpc::ServerContext* /*context*/, const ::oteldemo::DeleteFlagRequest* /*request*/, ::oteldemo::DeleteFlagResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedDeleteFlag(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::oteldemo::DeleteFlagRequest,::oteldemo::DeleteFlagResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_GetFlag<WithStreamedUnaryMethod_CreateFlag<WithStreamedUnaryMethod_UpdateFlag<WithStreamedUnaryMethod_ListFlags<WithStreamedUnaryMethod_DeleteFlag<Service > > > > > StreamedUnaryService;
  typedef Service SplitStreamedService;
  typedef WithStreamedUnaryMethod_GetFlag<WithStreamedUnaryMethod_CreateFlag<WithStreamedUnaryMethod_UpdateFlag<WithStreamedUnaryMethod_ListFlags<WithStreamedUnaryMethod_DeleteFlag<Service > > > > > StreamedService;
};

}  // namespace oteldemo


#endif  // GRPC_demo_2eproto__INCLUDED