// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// 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.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: cube.proto

#ifndef PROTOBUF_cube_2eproto__INCLUDED
#define PROTOBUF_cube_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3001000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/service.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace rec {
namespace mcube {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_cube_2eproto();
void protobuf_InitDefaults_cube_2eproto();
void protobuf_AssignDesc_cube_2eproto();
void protobuf_ShutdownFile_cube_2eproto();

class DictRequest;
class DictResponse;
class DictValue;
class ParallelDictRequest;
class ParallelDictResponse;

// ===================================================================

class DictRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rec.mcube.DictRequest) */ {
 public:
  DictRequest();
  virtual ~DictRequest();

  DictRequest(const DictRequest& from);

  inline DictRequest& operator=(const DictRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DictRequest& default_instance();

  static const DictRequest* internal_default_instance();

  void Swap(DictRequest* other);

  // implements Message ----------------------------------------------

  inline DictRequest* New() const { return New(NULL); }

  DictRequest* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DictRequest& from);
  void MergeFrom(const DictRequest& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DictRequest* other);
  void UnsafeMergeFrom(const DictRequest& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated uint64 keys = 1;
  int keys_size() const;
  void clear_keys();
  static const int kKeysFieldNumber = 1;
  ::google::protobuf::uint64 keys(int index) const;
  void set_keys(int index, ::google::protobuf::uint64 value);
  void add_keys(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      keys() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_keys();

  // optional bool version_required = 2 [default = false];
  bool has_version_required() const;
  void clear_version_required();
  static const int kVersionRequiredFieldNumber = 2;
  bool version_required() const;
  void set_version_required(bool value);

  // @@protoc_insertion_point(class_scope:rec.mcube.DictRequest)
 private:
  inline void set_has_version_required();
  inline void clear_has_version_required();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > keys_;
  bool version_required_;
  friend void  protobuf_InitDefaults_cube_2eproto_impl();
  friend void  protobuf_AddDesc_cube_2eproto_impl();
  friend void protobuf_AssignDesc_cube_2eproto();
  friend void protobuf_ShutdownFile_cube_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<DictRequest> DictRequest_default_instance_;

// -------------------------------------------------------------------

class DictValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rec.mcube.DictValue) */ {
 public:
  DictValue();
  virtual ~DictValue();

  DictValue(const DictValue& from);

  inline DictValue& operator=(const DictValue& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DictValue& default_instance();

  static const DictValue* internal_default_instance();

  void Swap(DictValue* other);

  // implements Message ----------------------------------------------

  inline DictValue* New() const { return New(NULL); }

  DictValue* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DictValue& from);
  void MergeFrom(const DictValue& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DictValue* other);
  void UnsafeMergeFrom(const DictValue& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 status = 1;
  bool has_status() const;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  ::google::protobuf::uint32 status() const;
  void set_status(::google::protobuf::uint32 value);

  // required bytes value = 2;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  void set_value(const char* value);
  void set_value(const void* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:rec.mcube.DictValue)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_value();
  inline void clear_has_value();

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  ::google::protobuf::uint32 status_;
  friend void  protobuf_InitDefaults_cube_2eproto_impl();
  friend void  protobuf_AddDesc_cube_2eproto_impl();
  friend void protobuf_AssignDesc_cube_2eproto();
  friend void protobuf_ShutdownFile_cube_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<DictValue> DictValue_default_instance_;

// -------------------------------------------------------------------

class DictResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rec.mcube.DictResponse) */ {
 public:
  DictResponse();
  virtual ~DictResponse();

  DictResponse(const DictResponse& from);

  inline DictResponse& operator=(const DictResponse& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DictResponse& default_instance();

  static const DictResponse* internal_default_instance();

  void Swap(DictResponse* other);

  // implements Message ----------------------------------------------

  inline DictResponse* New() const { return New(NULL); }

  DictResponse* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DictResponse& from);
  void MergeFrom(const DictResponse& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DictResponse* other);
  void UnsafeMergeFrom(const DictResponse& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .rec.mcube.DictValue values = 1;
  int values_size() const;
  void clear_values();
  static const int kValuesFieldNumber = 1;
  const ::rec::mcube::DictValue& values(int index) const;
  ::rec::mcube::DictValue* mutable_values(int index);
  ::rec::mcube::DictValue* add_values();
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >*
      mutable_values();
  const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >&
      values() const;

  // optional string version = 2;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 2;
  const ::std::string& version() const;
  void set_version(const ::std::string& value);
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  ::std::string* mutable_version();
  ::std::string* release_version();
  void set_allocated_version(::std::string* version);

  // @@protoc_insertion_point(class_scope:rec.mcube.DictResponse)
 private:
  inline void set_has_version();
  inline void clear_has_version();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue > values_;
  ::google::protobuf::internal::ArenaStringPtr version_;
  friend void  protobuf_InitDefaults_cube_2eproto_impl();
  friend void  protobuf_AddDesc_cube_2eproto_impl();
  friend void protobuf_AssignDesc_cube_2eproto();
  friend void protobuf_ShutdownFile_cube_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<DictResponse> DictResponse_default_instance_;

// -------------------------------------------------------------------

class ParallelDictRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rec.mcube.ParallelDictRequest) */ {
 public:
  ParallelDictRequest();
  virtual ~ParallelDictRequest();

  ParallelDictRequest(const ParallelDictRequest& from);

  inline ParallelDictRequest& operator=(const ParallelDictRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ParallelDictRequest& default_instance();

  static const ParallelDictRequest* internal_default_instance();

  void Swap(ParallelDictRequest* other);

  // implements Message ----------------------------------------------

  inline ParallelDictRequest* New() const { return New(NULL); }

  ParallelDictRequest* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ParallelDictRequest& from);
  void MergeFrom(const ParallelDictRequest& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ParallelDictRequest* other);
  void UnsafeMergeFrom(const ParallelDictRequest& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .rec.mcube.DictRequest requests = 2;
  int requests_size() const;
  void clear_requests();
  static const int kRequestsFieldNumber = 2;
  const ::rec::mcube::DictRequest& requests(int index) const;
  ::rec::mcube::DictRequest* mutable_requests(int index);
  ::rec::mcube::DictRequest* add_requests();
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >*
      mutable_requests();
  const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >&
      requests() const;

  // @@protoc_insertion_point(class_scope:rec.mcube.ParallelDictRequest)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest > requests_;
  friend void  protobuf_InitDefaults_cube_2eproto_impl();
  friend void  protobuf_AddDesc_cube_2eproto_impl();
  friend void protobuf_AssignDesc_cube_2eproto();
  friend void protobuf_ShutdownFile_cube_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<ParallelDictRequest> ParallelDictRequest_default_instance_;

// -------------------------------------------------------------------

class ParallelDictResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:rec.mcube.ParallelDictResponse) */ {
 public:
  ParallelDictResponse();
  virtual ~ParallelDictResponse();

  ParallelDictResponse(const ParallelDictResponse& from);

  inline ParallelDictResponse& operator=(const ParallelDictResponse& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ParallelDictResponse& default_instance();

  static const ParallelDictResponse* internal_default_instance();

  void Swap(ParallelDictResponse* other);

  // implements Message ----------------------------------------------

  inline ParallelDictResponse* New() const { return New(NULL); }

  ParallelDictResponse* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ParallelDictResponse& from);
  void MergeFrom(const ParallelDictResponse& from);
  void Clear();
  bool IsInitialized() const;

  size_t ByteSizeLong() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ParallelDictResponse* other);
  void UnsafeMergeFrom(const ParallelDictResponse& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .rec.mcube.DictResponse responses = 1;
  int responses_size() const;
  void clear_responses();
  static const int kResponsesFieldNumber = 1;
  const ::rec::mcube::DictResponse& responses(int index) const;
  ::rec::mcube::DictResponse* mutable_responses(int index);
  ::rec::mcube::DictResponse* add_responses();
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >*
      mutable_responses();
  const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >&
      responses() const;

  // @@protoc_insertion_point(class_scope:rec.mcube.ParallelDictResponse)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse > responses_;
  friend void  protobuf_InitDefaults_cube_2eproto_impl();
  friend void  protobuf_AddDesc_cube_2eproto_impl();
  friend void protobuf_AssignDesc_cube_2eproto();
  friend void protobuf_ShutdownFile_cube_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<ParallelDictResponse> ParallelDictResponse_default_instance_;

// ===================================================================

class DictService_Stub;

class DictService : public ::google::protobuf::Service {
 protected:
  // This class should be treated as an abstract interface.
  inline DictService() {};
 public:
  virtual ~DictService();

  typedef DictService_Stub Stub;

  static const ::google::protobuf::ServiceDescriptor* descriptor();

  virtual void seek(::google::protobuf::RpcController* controller,
                       const ::rec::mcube::DictRequest* request,
                       ::rec::mcube::DictResponse* response,
                       ::google::protobuf::Closure* done);
  virtual void parallel_seek(::google::protobuf::RpcController* controller,
                       const ::rec::mcube::ParallelDictRequest* request,
                       ::rec::mcube::ParallelDictResponse* response,
                       ::google::protobuf::Closure* done);

  // implements Service ----------------------------------------------

  const ::google::protobuf::ServiceDescriptor* GetDescriptor();
  void CallMethod(const ::google::protobuf::MethodDescriptor* method,
                  ::google::protobuf::RpcController* controller,
                  const ::google::protobuf::Message* request,
                  ::google::protobuf::Message* response,
                  ::google::protobuf::Closure* done);
  const ::google::protobuf::Message& GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const;
  const ::google::protobuf::Message& GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const;

 private:
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DictService);
};

class DictService_Stub : public DictService {
 public:
  DictService_Stub(::google::protobuf::RpcChannel* channel);
  DictService_Stub(::google::protobuf::RpcChannel* channel,
                   ::google::protobuf::Service::ChannelOwnership ownership);
  ~DictService_Stub();

  inline ::google::protobuf::RpcChannel* channel() { return channel_; }

  // implements DictService ------------------------------------------

  void seek(::google::protobuf::RpcController* controller,
                       const ::rec::mcube::DictRequest* request,
                       ::rec::mcube::DictResponse* response,
                       ::google::protobuf::Closure* done);
  void parallel_seek(::google::protobuf::RpcController* controller,
                       const ::rec::mcube::ParallelDictRequest* request,
                       ::rec::mcube::ParallelDictResponse* response,
                       ::google::protobuf::Closure* done);
 private:
  ::google::protobuf::RpcChannel* channel_;
  bool owns_channel_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DictService_Stub);
};


// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// DictRequest

// repeated uint64 keys = 1;
inline int DictRequest::keys_size() const {
  return keys_.size();
}
inline void DictRequest::clear_keys() {
  keys_.Clear();
}
inline ::google::protobuf::uint64 DictRequest::keys(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictRequest.keys)
  return keys_.Get(index);
}
inline void DictRequest::set_keys(int index, ::google::protobuf::uint64 value) {
  keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictRequest.keys)
}
inline void DictRequest::add_keys(::google::protobuf::uint64 value) {
  keys_.Add(value);
  // @@protoc_insertion_point(field_add:rec.mcube.DictRequest.keys)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
DictRequest::keys() const {
  // @@protoc_insertion_point(field_list:rec.mcube.DictRequest.keys)
  return keys_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
DictRequest::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.DictRequest.keys)
  return &keys_;
}

// optional bool version_required = 2 [default = false];
inline bool DictRequest::has_version_required() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DictRequest::set_has_version_required() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DictRequest::clear_has_version_required() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DictRequest::clear_version_required() {
  version_required_ = false;
  clear_has_version_required();
}
inline bool DictRequest::version_required() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictRequest.version_required)
  return version_required_;
}
inline void DictRequest::set_version_required(bool value) {
  set_has_version_required();
  version_required_ = value;
  // @@protoc_insertion_point(field_set:rec.mcube.DictRequest.version_required)
}

inline const DictRequest* DictRequest::internal_default_instance() {
  return &DictRequest_default_instance_.get();
}
// -------------------------------------------------------------------

// DictValue

// required uint32 status = 1;
inline bool DictValue::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DictValue::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DictValue::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DictValue::clear_status() {
  status_ = 0u;
  clear_has_status();
}
inline ::google::protobuf::uint32 DictValue::status() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictValue.status)
  return status_;
}
inline void DictValue::set_status(::google::protobuf::uint32 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:rec.mcube.DictValue.status)
}

// required bytes value = 2;
inline bool DictValue::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DictValue::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DictValue::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DictValue::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
inline const ::std::string& DictValue::value() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictValue.value)
  return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DictValue::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictValue.value)
}
inline void DictValue::set_value(const char* value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rec.mcube.DictValue.value)
}
inline void DictValue::set_value(const void* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rec.mcube.DictValue.value)
}
inline ::std::string* DictValue::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictValue.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DictValue::release_value() {
  // @@protoc_insertion_point(field_release:rec.mcube.DictValue.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DictValue::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:rec.mcube.DictValue.value)
}

inline const DictValue* DictValue::internal_default_instance() {
  return &DictValue_default_instance_.get();
}
// -------------------------------------------------------------------

// DictResponse

// repeated .rec.mcube.DictValue values = 1;
inline int DictResponse::values_size() const {
  return values_.size();
}
inline void DictResponse::clear_values() {
  values_.Clear();
}
inline const ::rec::mcube::DictValue& DictResponse::values(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictResponse.values)
  return values_.Get(index);
}
inline ::rec::mcube::DictValue* DictResponse::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictResponse.values)
  return values_.Mutable(index);
}
inline ::rec::mcube::DictValue* DictResponse::add_values() {
  // @@protoc_insertion_point(field_add:rec.mcube.DictResponse.values)
  return values_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >*
DictResponse::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.DictResponse.values)
  return &values_;
}
inline const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >&
DictResponse::values() const {
  // @@protoc_insertion_point(field_list:rec.mcube.DictResponse.values)
  return values_;
}

// optional string version = 2;
inline bool DictResponse::has_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DictResponse::set_has_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DictResponse::clear_has_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DictResponse::clear_version() {
  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_version();
}
inline const ::std::string& DictResponse::version() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictResponse.version)
  return version_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DictResponse::set_version(const ::std::string& value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictResponse.version)
}
inline void DictResponse::set_version(const char* value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rec.mcube.DictResponse.version)
}
inline void DictResponse::set_version(const char* value, size_t size) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rec.mcube.DictResponse.version)
}
inline ::std::string* DictResponse::mutable_version() {
  set_has_version();
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictResponse.version)
  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* DictResponse::release_version() {
  // @@protoc_insertion_point(field_release:rec.mcube.DictResponse.version)
  clear_has_version();
  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void DictResponse::set_allocated_version(::std::string* version) {
  if (version != NULL) {
    set_has_version();
  } else {
    clear_has_version();
  }
  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
  // @@protoc_insertion_point(field_set_allocated:rec.mcube.DictResponse.version)
}

inline const DictResponse* DictResponse::internal_default_instance() {
  return &DictResponse_default_instance_.get();
}
// -------------------------------------------------------------------

// ParallelDictRequest

// repeated .rec.mcube.DictRequest requests = 2;
inline int ParallelDictRequest::requests_size() const {
  return requests_.size();
}
inline void ParallelDictRequest::clear_requests() {
  requests_.Clear();
}
inline const ::rec::mcube::DictRequest& ParallelDictRequest::requests(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.ParallelDictRequest.requests)
  return requests_.Get(index);
}
inline ::rec::mcube::DictRequest* ParallelDictRequest::mutable_requests(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.ParallelDictRequest.requests)
  return requests_.Mutable(index);
}
inline ::rec::mcube::DictRequest* ParallelDictRequest::add_requests() {
  // @@protoc_insertion_point(field_add:rec.mcube.ParallelDictRequest.requests)
  return requests_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >*
ParallelDictRequest::mutable_requests() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.ParallelDictRequest.requests)
  return &requests_;
}
inline const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >&
ParallelDictRequest::requests() const {
  // @@protoc_insertion_point(field_list:rec.mcube.ParallelDictRequest.requests)
  return requests_;
}

inline const ParallelDictRequest* ParallelDictRequest::internal_default_instance() {
  return &ParallelDictRequest_default_instance_.get();
}
// -------------------------------------------------------------------

// ParallelDictResponse

// repeated .rec.mcube.DictResponse responses = 1;
inline int ParallelDictResponse::responses_size() const {
  return responses_.size();
}
inline void ParallelDictResponse::clear_responses() {
  responses_.Clear();
}
inline const ::rec::mcube::DictResponse& ParallelDictResponse::responses(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.ParallelDictResponse.responses)
  return responses_.Get(index);
}
inline ::rec::mcube::DictResponse* ParallelDictResponse::mutable_responses(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.ParallelDictResponse.responses)
  return responses_.Mutable(index);
}
inline ::rec::mcube::DictResponse* ParallelDictResponse::add_responses() {
  // @@protoc_insertion_point(field_add:rec.mcube.ParallelDictResponse.responses)
  return responses_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >*
ParallelDictResponse::mutable_responses() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.ParallelDictResponse.responses)
  return &responses_;
}
inline const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >&
ParallelDictResponse::responses() const {
  // @@protoc_insertion_point(field_list:rec.mcube.ParallelDictResponse.responses)
  return responses_;
}

inline const ParallelDictResponse* ParallelDictResponse::internal_default_instance() {
  return &ParallelDictResponse_default_instance_.get();
}
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace mcube
}  // namespace rec

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_cube_2eproto__INCLUDED
