src/server/storage.grpc.pb.h - master - smychkov/SStorage

src/server/storage.grpc.pb.h
1 191 строка73 KB
Андрей Смычков
feat: HTTP + gRPC servers with new key-value API
25 апр 2026, 09:21
25 апр 2026, 09:211c6add8
// Generated by the gRPC C++ plugin.
// If you make any local change, they will be lost.
// source: storage.proto
// Original file comments:
// ============================================================================
// SStorage gRPC API
// ============================================================================
// Key-value API (как в Bigtable): bytes key → bytes value.
// Операции: Put, Get, Delete, Scan (streaming), Stats, Flush, Compact.
// ============================================================================
//
#ifndef GRPC_storage_2eproto__INCLUDED
#define GRPC_storage_2eproto__INCLUDED

#include "storage.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>
#include <grpcpp/ports_def.inc>

namespace sstorage {

class Storage final {
 public:
  static constexpr char const* service_full_name() {
    return "sstorage.Storage";
  }
  class StubInterface {
   public:
    virtual ~StubInterface() {}
    virtual ::grpc::Status Put(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::sstorage::PutResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::PutResponse>> AsyncPut(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::PutResponse>>(AsyncPutRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::PutResponse>> PrepareAsyncPut(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::PutResponse>>(PrepareAsyncPutRaw(context, request, cq));
    }
    virtual ::grpc::Status Get(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::sstorage::GetResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>> AsyncGet(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>>(AsyncGetRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
    }
    virtual ::grpc::Status Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::sstorage::DeleteResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>> AsyncDelete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>>(AsyncDeleteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>> PrepareAsyncDelete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>>(PrepareAsyncDeleteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientReaderInterface< ::sstorage::ScanResponse>> Scan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request) {
      return std::unique_ptr< ::grpc::ClientReaderInterface< ::sstorage::ScanResponse>>(ScanRaw(context, request));
    }
    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>> AsyncScan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>>(AsyncScanRaw(context, request, cq, tag));
    }
    std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>> PrepareAsyncScan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>>(PrepareAsyncScanRaw(context, request, cq));
    }
    virtual ::grpc::Status Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::sstorage::StatsResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>> AsyncStats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>>(AsyncStatsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>> PrepareAsyncStats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>>(PrepareAsyncStatsRaw(context, request, cq));
    }
    virtual ::grpc::Status Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::sstorage::FlushResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>> AsyncFlush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>>(AsyncFlushRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>> PrepareAsyncFlush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>>(PrepareAsyncFlushRaw(context, request, cq));
    }
    virtual ::grpc::Status Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::sstorage::CompactResponse* response) = 0;
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>> AsyncCompact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>>(AsyncCompactRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>>(PrepareAsyncCompactRaw(context, request, cq));
    }
    class async_interface {
     public:
      virtual ~async_interface() {}
      virtual void Put(::grpc::ClientContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Put(::grpc::ClientContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Get(::grpc::ClientContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Get(::grpc::ClientContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Scan(::grpc::ClientContext* context, const ::sstorage::ScanRequest* request, ::grpc::ClientReadReactor< ::sstorage::ScanResponse>* reactor) = 0;
      virtual void Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
      virtual void Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* response, std::function<void(::grpc::Status)>) = 0;
      virtual void Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* 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< ::sstorage::PutResponse>* AsyncPutRaw(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::PutResponse>* PrepareAsyncPutRaw(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>* AsyncDeleteRaw(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::DeleteResponse>* PrepareAsyncDeleteRaw(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientReaderInterface< ::sstorage::ScanResponse>* ScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request) = 0;
    virtual ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>* AsyncScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
    virtual ::grpc::ClientAsyncReaderInterface< ::sstorage::ScanResponse>* PrepareAsyncScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>* AsyncStatsRaw(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::StatsResponse>* PrepareAsyncStatsRaw(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>* AsyncFlushRaw(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::FlushResponse>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>* AsyncCompactRaw(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) = 0;
    virtual ::grpc::ClientAsyncResponseReaderInterface< ::sstorage::CompactResponse>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::sstorage::CompactRequest& 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 Put(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::sstorage::PutResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::PutResponse>> AsyncPut(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::PutResponse>>(AsyncPutRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::PutResponse>> PrepareAsyncPut(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::PutResponse>>(PrepareAsyncPutRaw(context, request, cq));
    }
    ::grpc::Status Get(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::sstorage::GetResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>> AsyncGet(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>>(AsyncGetRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
    }
    ::grpc::Status Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::sstorage::DeleteResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>> AsyncDelete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>>(AsyncDeleteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>> PrepareAsyncDelete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>>(PrepareAsyncDeleteRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientReader< ::sstorage::ScanResponse>> Scan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request) {
      return std::unique_ptr< ::grpc::ClientReader< ::sstorage::ScanResponse>>(ScanRaw(context, request));
    }
    std::unique_ptr< ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>> AsyncScan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
      return std::unique_ptr< ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>>(AsyncScanRaw(context, request, cq, tag));
    }
    std::unique_ptr< ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>> PrepareAsyncScan(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>>(PrepareAsyncScanRaw(context, request, cq));
    }
    ::grpc::Status Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::sstorage::StatsResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>> AsyncStats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>>(AsyncStatsRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>> PrepareAsyncStats(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>>(PrepareAsyncStatsRaw(context, request, cq));
    }
    ::grpc::Status Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::sstorage::FlushResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>> AsyncFlush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>>(AsyncFlushRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>> PrepareAsyncFlush(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>>(PrepareAsyncFlushRaw(context, request, cq));
    }
    ::grpc::Status Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::sstorage::CompactResponse* response) override;
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>> AsyncCompact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>>(AsyncCompactRaw(context, request, cq));
    }
    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) {
      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>>(PrepareAsyncCompactRaw(context, request, cq));
    }
    class async final :
      public StubInterface::async_interface {
     public:
      void Put(::grpc::ClientContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response, std::function<void(::grpc::Status)>) override;
      void Put(::grpc::ClientContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Get(::grpc::ClientContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response, std::function<void(::grpc::Status)>) override;
      void Get(::grpc::ClientContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response, std::function<void(::grpc::Status)>) override;
      void Delete(::grpc::ClientContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Scan(::grpc::ClientContext* context, const ::sstorage::ScanRequest* request, ::grpc::ClientReadReactor< ::sstorage::ScanResponse>* reactor) override;
      void Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response, std::function<void(::grpc::Status)>) override;
      void Stats(::grpc::ClientContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response, std::function<void(::grpc::Status)>) override;
      void Flush(::grpc::ClientContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
      void Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* response, std::function<void(::grpc::Status)>) override;
      void Compact(::grpc::ClientContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* 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< ::sstorage::PutResponse>* AsyncPutRaw(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::PutResponse>* PrepareAsyncPutRaw(::grpc::ClientContext* context, const ::sstorage::PutRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::sstorage::GetRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>* AsyncDeleteRaw(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::DeleteResponse>* PrepareAsyncDeleteRaw(::grpc::ClientContext* context, const ::sstorage::DeleteRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientReader< ::sstorage::ScanResponse>* ScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request) override;
    ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>* AsyncScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
    ::grpc::ClientAsyncReader< ::sstorage::ScanResponse>* PrepareAsyncScanRaw(::grpc::ClientContext* context, const ::sstorage::ScanRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>* AsyncStatsRaw(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::StatsResponse>* PrepareAsyncStatsRaw(::grpc::ClientContext* context, const ::sstorage::StatsRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>* AsyncFlushRaw(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::FlushResponse>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::sstorage::FlushRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>* AsyncCompactRaw(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) override;
    ::grpc::ClientAsyncResponseReader< ::sstorage::CompactResponse>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::sstorage::CompactRequest& request, ::grpc::CompletionQueue* cq) override;
    const ::grpc::internal::RpcMethod rpcmethod_Put_;
    const ::grpc::internal::RpcMethod rpcmethod_Get_;
    const ::grpc::internal::RpcMethod rpcmethod_Delete_;
    const ::grpc::internal::RpcMethod rpcmethod_Scan_;
    const ::grpc::internal::RpcMethod rpcmethod_Stats_;
    const ::grpc::internal::RpcMethod rpcmethod_Flush_;
    const ::grpc::internal::RpcMethod rpcmethod_Compact_;
  };
  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 Put(::grpc::ServerContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response);
    virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response);
    virtual ::grpc::Status Delete(::grpc::ServerContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response);
    virtual ::grpc::Status Scan(::grpc::ServerContext* context, const ::sstorage::ScanRequest* request, ::grpc::ServerWriter< ::sstorage::ScanResponse>* writer);
    virtual ::grpc::Status Stats(::grpc::ServerContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response);
    virtual ::grpc::Status Flush(::grpc::ServerContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response);
    virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* response);
  };
  template <class BaseClass>
  class WithAsyncMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Put() {
      ::grpc::Service::MarkMethodAsync(0);
    }
    ~WithAsyncMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestPut(::grpc::ServerContext* context, ::sstorage::PutRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::PutResponse>* 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_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Get() {
      ::grpc::Service::MarkMethodAsync(1);
    }
    ~WithAsyncMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGet(::grpc::ServerContext* context, ::sstorage::GetRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::GetResponse>* 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_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Delete() {
      ::grpc::Service::MarkMethodAsync(2);
    }
    ~WithAsyncMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestDelete(::grpc::ServerContext* context, ::sstorage::DeleteRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::DeleteResponse>* 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_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Scan() {
      ::grpc::Service::MarkMethodAsync(3);
    }
    ~WithAsyncMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestScan(::grpc::ServerContext* context, ::sstorage::ScanRequest* request, ::grpc::ServerAsyncWriter< ::sstorage::ScanResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Stats() {
      ::grpc::Service::MarkMethodAsync(4);
    }
    ~WithAsyncMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestStats(::grpc::ServerContext* context, ::sstorage::StatsRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::StatsResponse>* 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 WithAsyncMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Flush() {
      ::grpc::Service::MarkMethodAsync(5);
    }
    ~WithAsyncMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestFlush(::grpc::ServerContext* context, ::sstorage::FlushRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::FlushResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithAsyncMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithAsyncMethod_Compact() {
      ::grpc::Service::MarkMethodAsync(6);
    }
    ~WithAsyncMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCompact(::grpc::ServerContext* context, ::sstorage::CompactRequest* request, ::grpc::ServerAsyncResponseWriter< ::sstorage::CompactResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  typedef WithAsyncMethod_Put<WithAsyncMethod_Get<WithAsyncMethod_Delete<WithAsyncMethod_Scan<WithAsyncMethod_Stats<WithAsyncMethod_Flush<WithAsyncMethod_Compact<Service > > > > > > > AsyncService;
  template <class BaseClass>
  class WithCallbackMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Put() {
      ::grpc::Service::MarkMethodCallback(0,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::PutRequest, ::sstorage::PutResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::PutRequest* request, ::sstorage::PutResponse* response) { return this->Put(context, request, response); }));}
    void SetMessageAllocatorFor_Put(
        ::grpc::MessageAllocator< ::sstorage::PutRequest, ::sstorage::PutResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::PutRequest, ::sstorage::PutResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Put(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Get() {
      ::grpc::Service::MarkMethodCallback(1,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::GetRequest, ::sstorage::GetResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::GetRequest* request, ::sstorage::GetResponse* response) { return this->Get(context, request, response); }));}
    void SetMessageAllocatorFor_Get(
        ::grpc::MessageAllocator< ::sstorage::GetRequest, ::sstorage::GetResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::GetRequest, ::sstorage::GetResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Get(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Delete() {
      ::grpc::Service::MarkMethodCallback(2,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::DeleteRequest, ::sstorage::DeleteResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::DeleteRequest* request, ::sstorage::DeleteResponse* response) { return this->Delete(context, request, response); }));}
    void SetMessageAllocatorFor_Delete(
        ::grpc::MessageAllocator< ::sstorage::DeleteRequest, ::sstorage::DeleteResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::DeleteRequest, ::sstorage::DeleteResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Delete(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Scan() {
      ::grpc::Service::MarkMethodCallback(3,
          new ::grpc::internal::CallbackServerStreamingHandler< ::sstorage::ScanRequest, ::sstorage::ScanResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::ScanRequest* request) { return this->Scan(context, request); }));
    }
    ~WithCallbackMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerWriteReactor< ::sstorage::ScanResponse>* Scan(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Stats() {
      ::grpc::Service::MarkMethodCallback(4,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::StatsRequest, ::sstorage::StatsResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::StatsRequest* request, ::sstorage::StatsResponse* response) { return this->Stats(context, request, response); }));}
    void SetMessageAllocatorFor_Stats(
        ::grpc::MessageAllocator< ::sstorage::StatsRequest, ::sstorage::StatsResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::StatsRequest, ::sstorage::StatsResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Stats(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Flush() {
      ::grpc::Service::MarkMethodCallback(5,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::FlushRequest, ::sstorage::FlushResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::FlushRequest* request, ::sstorage::FlushResponse* response) { return this->Flush(context, request, response); }));}
    void SetMessageAllocatorFor_Flush(
        ::grpc::MessageAllocator< ::sstorage::FlushRequest, ::sstorage::FlushResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::FlushRequest, ::sstorage::FlushResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Flush(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithCallbackMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithCallbackMethod_Compact() {
      ::grpc::Service::MarkMethodCallback(6,
          new ::grpc::internal::CallbackUnaryHandler< ::sstorage::CompactRequest, ::sstorage::CompactResponse>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::sstorage::CompactRequest* request, ::sstorage::CompactResponse* response) { return this->Compact(context, request, response); }));}
    void SetMessageAllocatorFor_Compact(
        ::grpc::MessageAllocator< ::sstorage::CompactRequest, ::sstorage::CompactResponse>* allocator) {
      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(6);
      static_cast<::grpc::internal::CallbackUnaryHandler< ::sstorage::CompactRequest, ::sstorage::CompactResponse>*>(handler)
              ->SetMessageAllocator(allocator);
    }
    ~WithCallbackMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Compact(
      ::grpc::CallbackServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/)  { return nullptr; }
  };
  typedef WithCallbackMethod_Put<WithCallbackMethod_Get<WithCallbackMethod_Delete<WithCallbackMethod_Scan<WithCallbackMethod_Stats<WithCallbackMethod_Flush<WithCallbackMethod_Compact<Service > > > > > > > CallbackService;
  typedef CallbackService ExperimentalCallbackService;
  template <class BaseClass>
  class WithGenericMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Put() {
      ::grpc::Service::MarkMethodGeneric(0);
    }
    ~WithGenericMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Get() {
      ::grpc::Service::MarkMethodGeneric(1);
    }
    ~WithGenericMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Delete() {
      ::grpc::Service::MarkMethodGeneric(2);
    }
    ~WithGenericMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Scan() {
      ::grpc::Service::MarkMethodGeneric(3);
    }
    ~WithGenericMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Stats() {
      ::grpc::Service::MarkMethodGeneric(4);
    }
    ~WithGenericMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Flush() {
      ::grpc::Service::MarkMethodGeneric(5);
    }
    ~WithGenericMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithGenericMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithGenericMethod_Compact() {
      ::grpc::Service::MarkMethodGeneric(6);
    }
    ~WithGenericMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
  };
  template <class BaseClass>
  class WithRawMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Put() {
      ::grpc::Service::MarkMethodRaw(0);
    }
    ~WithRawMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestPut(::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_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Get() {
      ::grpc::Service::MarkMethodRaw(1);
    }
    ~WithRawMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestGet(::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_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Delete() {
      ::grpc::Service::MarkMethodRaw(2);
    }
    ~WithRawMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestDelete(::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_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Scan() {
      ::grpc::Service::MarkMethodRaw(3);
    }
    ~WithRawMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestScan(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
      ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Stats() {
      ::grpc::Service::MarkMethodRaw(4);
    }
    ~WithRawMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestStats(::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 WithRawMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Flush() {
      ::grpc::Service::MarkMethodRaw(5);
    }
    ~WithRawMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestFlush(::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(5, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawMethod_Compact() {
      ::grpc::Service::MarkMethodRaw(6);
    }
    ~WithRawMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    void RequestCompact(::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(6, context, request, response, new_call_cq, notification_cq, tag);
    }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Put() {
      ::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->Put(context, request, response); }));
    }
    ~WithRawCallbackMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Put(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Get() {
      ::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->Get(context, request, response); }));
    }
    ~WithRawCallbackMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Get(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Delete() {
      ::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->Delete(context, request, response); }));
    }
    ~WithRawCallbackMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Delete(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Scan() {
      ::grpc::Service::MarkMethodRawCallback(3,
          new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->Scan(context, request); }));
    }
    ~WithRawCallbackMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* Scan(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Stats() {
      ::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->Stats(context, request, response); }));
    }
    ~WithRawCallbackMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Stats(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Flush() {
      ::grpc::Service::MarkMethodRawCallback(5,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Flush(context, request, response); }));
    }
    ~WithRawCallbackMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Flush(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithRawCallbackMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithRawCallbackMethod_Compact() {
      ::grpc::Service::MarkMethodRawCallback(6,
          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
            [this](
                   ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Compact(context, request, response); }));
    }
    ~WithRawCallbackMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable synchronous version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    virtual ::grpc::ServerUnaryReactor* Compact(
      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)  { return nullptr; }
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Put : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Put() {
      ::grpc::Service::MarkMethodStreamed(0,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::PutRequest, ::sstorage::PutResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::PutRequest, ::sstorage::PutResponse>* streamer) {
                       return this->StreamedPut(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Put() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Put(::grpc::ServerContext* /*context*/, const ::sstorage::PutRequest* /*request*/, ::sstorage::PutResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedPut(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::PutRequest,::sstorage::PutResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Get : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Get() {
      ::grpc::Service::MarkMethodStreamed(1,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::GetRequest, ::sstorage::GetResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::GetRequest, ::sstorage::GetResponse>* streamer) {
                       return this->StreamedGet(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Get() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::sstorage::GetRequest* /*request*/, ::sstorage::GetResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedGet(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::GetRequest,::sstorage::GetResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Delete : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Delete() {
      ::grpc::Service::MarkMethodStreamed(2,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::DeleteRequest, ::sstorage::DeleteResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::DeleteRequest, ::sstorage::DeleteResponse>* streamer) {
                       return this->StreamedDelete(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Delete() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Delete(::grpc::ServerContext* /*context*/, const ::sstorage::DeleteRequest* /*request*/, ::sstorage::DeleteResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedDelete(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::DeleteRequest,::sstorage::DeleteResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Stats : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Stats() {
      ::grpc::Service::MarkMethodStreamed(4,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::StatsRequest, ::sstorage::StatsResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::StatsRequest, ::sstorage::StatsResponse>* streamer) {
                       return this->StreamedStats(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Stats() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Stats(::grpc::ServerContext* /*context*/, const ::sstorage::StatsRequest* /*request*/, ::sstorage::StatsResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedStats(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::StatsRequest,::sstorage::StatsResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Flush : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Flush() {
      ::grpc::Service::MarkMethodStreamed(5,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::FlushRequest, ::sstorage::FlushResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::FlushRequest, ::sstorage::FlushResponse>* streamer) {
                       return this->StreamedFlush(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Flush() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Flush(::grpc::ServerContext* /*context*/, const ::sstorage::FlushRequest* /*request*/, ::sstorage::FlushResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedFlush(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::FlushRequest,::sstorage::FlushResponse>* server_unary_streamer) = 0;
  };
  template <class BaseClass>
  class WithStreamedUnaryMethod_Compact : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithStreamedUnaryMethod_Compact() {
      ::grpc::Service::MarkMethodStreamed(6,
        new ::grpc::internal::StreamedUnaryHandler<
          ::sstorage::CompactRequest, ::sstorage::CompactResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerUnaryStreamer<
                     ::sstorage::CompactRequest, ::sstorage::CompactResponse>* streamer) {
                       return this->StreamedCompact(context,
                         streamer);
                  }));
    }
    ~WithStreamedUnaryMethod_Compact() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::sstorage::CompactRequest* /*request*/, ::sstorage::CompactResponse* /*response*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with streamed unary
    virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::sstorage::CompactRequest,::sstorage::CompactResponse>* server_unary_streamer) = 0;
  };
  typedef WithStreamedUnaryMethod_Put<WithStreamedUnaryMethod_Get<WithStreamedUnaryMethod_Delete<WithStreamedUnaryMethod_Stats<WithStreamedUnaryMethod_Flush<WithStreamedUnaryMethod_Compact<Service > > > > > > StreamedUnaryService;
  template <class BaseClass>
  class WithSplitStreamingMethod_Scan : public BaseClass {
   private:
    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
   public:
    WithSplitStreamingMethod_Scan() {
      ::grpc::Service::MarkMethodStreamed(3,
        new ::grpc::internal::SplitServerStreamingHandler<
          ::sstorage::ScanRequest, ::sstorage::ScanResponse>(
            [this](::grpc::ServerContext* context,
                   ::grpc::ServerSplitStreamer<
                     ::sstorage::ScanRequest, ::sstorage::ScanResponse>* streamer) {
                       return this->StreamedScan(context,
                         streamer);
                  }));
    }
    ~WithSplitStreamingMethod_Scan() override {
      BaseClassMustBeDerivedFromService(this);
    }
    // disable regular version of this method
    ::grpc::Status Scan(::grpc::ServerContext* /*context*/, const ::sstorage::ScanRequest* /*request*/, ::grpc::ServerWriter< ::sstorage::ScanResponse>* /*writer*/) override {
      abort();
      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
    }
    // replace default version of method with split streamed
    virtual ::grpc::Status StreamedScan(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::sstorage::ScanRequest,::sstorage::ScanResponse>* server_split_streamer) = 0;
  };
  typedef WithSplitStreamingMethod_Scan<Service > SplitStreamedService;
  typedef WithStreamedUnaryMethod_Put<WithStreamedUnaryMethod_Get<WithStreamedUnaryMethod_Delete<WithSplitStreamingMethod_Scan<WithStreamedUnaryMethod_Stats<WithStreamedUnaryMethod_Flush<WithStreamedUnaryMethod_Compact<Service > > > > > > > StreamedService;
};

}  // namespace sstorage


#include <grpcpp/ports_undef.inc>
#endif  // GRPC_storage_2eproto__INCLUDED