wwsearch/include/search_store.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "search_store.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace lsmsearch {

namespace {

const ::google::protobuf::Descriptor* StoreIndexField_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StoreIndexField_reflection_ = NULL;
const ::google::protobuf::Descriptor* StoreDocument_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StoreDocument_reflection_ = NULL;
const ::google::protobuf::Descriptor* StoreDocValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StoreDocValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* StoreMeta_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  StoreMeta_reflection_ = NULL;
const ::google::protobuf::Descriptor* MockData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MockData_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* MockData_Type_descriptor_ = NULL;
const ::google::protobuf::Descriptor* MockDataList_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MockDataList_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_search_5fstore_2eproto() {
  protobuf_AddDesc_search_5fstore_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "search_store.proto");
  GOOGLE_CHECK(file != NULL);
  StoreIndexField_descriptor_ = file->message_type(0);
  static const int StoreIndexField_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, field_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, field_flag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, field_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, numeric_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, string_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, terms_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, suffix_len_),
  };
  StoreIndexField_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StoreIndexField_descriptor_,
      StoreIndexField::default_instance_,
      StoreIndexField_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreIndexField, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StoreIndexField));
  StoreDocument_descriptor_ = file->message_type(1);
  static const int StoreDocument_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocument, document_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocument, fields_),
  };
  StoreDocument_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StoreDocument_descriptor_,
      StoreDocument::default_instance_,
      StoreDocument_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocument, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocument, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StoreDocument));
  StoreDocValue_descriptor_ = file->message_type(2);
  static const int StoreDocValue_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocValue, fields_),
  };
  StoreDocValue_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StoreDocValue_descriptor_,
      StoreDocValue::default_instance_,
      StoreDocValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocValue, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreDocValue, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StoreDocValue));
  StoreMeta_descriptor_ = file->message_type(3);
  static const int StoreMeta_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, total_documents_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, delete_documents_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, increase_seq_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, terms_count_),
  };
  StoreMeta_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      StoreMeta_descriptor_,
      StoreMeta::default_instance_,
      StoreMeta_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StoreMeta, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(StoreMeta));
  MockData_descriptor_ = file->message_type(4);
  static const int MockData_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, column_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, key_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, end_key_),
  };
  MockData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MockData_descriptor_,
      MockData::default_instance_,
      MockData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MockData));
  MockData_Type_descriptor_ = MockData_descriptor_->enum_type(0);
  MockDataList_descriptor_ = file->message_type(5);
  static const int MockDataList_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockDataList, mock_data_list_),
  };
  MockDataList_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      MockDataList_descriptor_,
      MockDataList::default_instance_,
      MockDataList_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockDataList, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MockDataList, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(MockDataList));
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_search_5fstore_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StoreIndexField_descriptor_, &StoreIndexField::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StoreDocument_descriptor_, &StoreDocument::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StoreDocValue_descriptor_, &StoreDocValue::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    StoreMeta_descriptor_, &StoreMeta::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MockData_descriptor_, &MockData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    MockDataList_descriptor_, &MockDataList::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_search_5fstore_2eproto() {
  delete StoreIndexField::default_instance_;
  delete StoreIndexField_reflection_;
  delete StoreDocument::default_instance_;
  delete StoreDocument_reflection_;
  delete StoreDocValue::default_instance_;
  delete StoreDocValue_reflection_;
  delete StoreMeta::default_instance_;
  delete StoreMeta_reflection_;
  delete MockData::default_instance_;
  delete MockData_reflection_;
  delete MockDataList::default_instance_;
  delete MockDataList_reflection_;
}

void protobuf_AddDesc_search_5fstore_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\022search_store.proto\022\tlsmsearch\"\233\001\n\017Stor"
    "eIndexField\022\020\n\010field_id\030\001 \002(\r\022\022\n\nfield_f"
    "lag\030\002 \002(\r\022\022\n\nfield_type\030\003 \002(\r\022\025\n\rnumeric"
    "_value\030\004 \001(\004\022\024\n\014string_value\030\005 \001(\014\022\r\n\005te"
    "rms\030\006 \003(\014\022\022\n\nsuffix_len\030\n \001(\r\"P\n\rStoreDo"
    "cument\022\023\n\013document_id\030\001 \002(\004\022*\n\006fields\030\002 "
    "\003(\0132\032.lsmsearch.StoreIndexField\";\n\rStore"
    "DocValue\022*\n\006fields\030\001 \003(\0132\032.lsmsearch.Sto"
    "reIndexField\"i\n\tStoreMeta\022\027\n\017total_docum"
    "ents\030\001 \001(\004\022\030\n\020delete_documents\030\002 \001(\004\022\024\n\014"
    "increase_seq\030\003 \001(\004\022\023\n\013terms_count\030\004 \001(\004\""
    "\302\001\n\010MockData\022\023\n\013column_type\030\001 \002(\r\022\013\n\003key"
    "\030\002 \002(\014\022\r\n\005value\030\003 \002(\014\022&\n\004type\030\004 \002(\0162\030.ls"
    "msearch.MockData.Type\022\017\n\007end_key\030\005 \001(\014\"L"
    "\n\004Type\022\014\n\010kUnknown\020\000\022\013\n\007kUpdate\020\001\022\n\n\006kMe"
    "rge\020\002\022\013\n\007kDelete\020\003\022\020\n\014kDeleteRange\020\004\";\n\014"
    "MockDataList\022+\n\016mock_data_list\030\001 \003(\0132\023.l"
    "smsearch.MockData", 697);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "search_store.proto", &protobuf_RegisterTypes);
  StoreIndexField::default_instance_ = new StoreIndexField();
  StoreDocument::default_instance_ = new StoreDocument();
  StoreDocValue::default_instance_ = new StoreDocValue();
  StoreMeta::default_instance_ = new StoreMeta();
  MockData::default_instance_ = new MockData();
  MockDataList::default_instance_ = new MockDataList();
  StoreIndexField::default_instance_->InitAsDefaultInstance();
  StoreDocument::default_instance_->InitAsDefaultInstance();
  StoreDocValue::default_instance_->InitAsDefaultInstance();
  StoreMeta::default_instance_->InitAsDefaultInstance();
  MockData::default_instance_->InitAsDefaultInstance();
  MockDataList::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_search_5fstore_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_search_5fstore_2eproto {
  StaticDescriptorInitializer_search_5fstore_2eproto() {
    protobuf_AddDesc_search_5fstore_2eproto();
  }
} static_descriptor_initializer_search_5fstore_2eproto_;


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

#ifndef _MSC_VER
const int StoreIndexField::kFieldIdFieldNumber;
const int StoreIndexField::kFieldFlagFieldNumber;
const int StoreIndexField::kFieldTypeFieldNumber;
const int StoreIndexField::kNumericValueFieldNumber;
const int StoreIndexField::kStringValueFieldNumber;
const int StoreIndexField::kTermsFieldNumber;
const int StoreIndexField::kSuffixLenFieldNumber;
#endif  // !_MSC_VER

StoreIndexField::StoreIndexField()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StoreIndexField::InitAsDefaultInstance() {
}

StoreIndexField::StoreIndexField(const StoreIndexField& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StoreIndexField::SharedCtor() {
  _cached_size_ = 0;
  field_id_ = 0u;
  field_flag_ = 0u;
  field_type_ = 0u;
  numeric_value_ = GOOGLE_ULONGLONG(0);
  string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  suffix_len_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StoreIndexField::~StoreIndexField() {
  SharedDtor();
}

void StoreIndexField::SharedDtor() {
  if (string_value_ != &::google::protobuf::internal::kEmptyString) {
    delete string_value_;
  }
  if (this != default_instance_) {
  }
}

void StoreIndexField::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StoreIndexField::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StoreIndexField_descriptor_;
}

const StoreIndexField& StoreIndexField::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

StoreIndexField* StoreIndexField::default_instance_ = NULL;

StoreIndexField* StoreIndexField::New() const {
  return new StoreIndexField;
}

void StoreIndexField::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    field_id_ = 0u;
    field_flag_ = 0u;
    field_type_ = 0u;
    numeric_value_ = GOOGLE_ULONGLONG(0);
    if (has_string_value()) {
      if (string_value_ != &::google::protobuf::internal::kEmptyString) {
        string_value_->clear();
      }
    }
    suffix_len_ = 0u;
  }
  terms_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StoreIndexField::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 field_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &field_id_)));
          set_has_field_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_field_flag;
        break;
      }
      
      // required uint32 field_flag = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_field_flag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &field_flag_)));
          set_has_field_flag();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_field_type;
        break;
      }
      
      // required uint32 field_type = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_field_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &field_type_)));
          set_has_field_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_numeric_value;
        break;
      }
      
      // optional uint64 numeric_value = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_numeric_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &numeric_value_)));
          set_has_numeric_value();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_string_value;
        break;
      }
      
      // optional bytes string_value = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_string_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_value()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_terms;
        break;
      }
      
      // repeated bytes terms = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_terms:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_terms()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_terms;
        if (input->ExpectTag(80)) goto parse_suffix_len;
        break;
      }
      
      // optional uint32 suffix_len = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_suffix_len:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &suffix_len_)));
          set_has_suffix_len();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StoreIndexField::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 field_id = 1;
  if (has_field_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->field_id(), output);
  }
  
  // required uint32 field_flag = 2;
  if (has_field_flag()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->field_flag(), output);
  }
  
  // required uint32 field_type = 3;
  if (has_field_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->field_type(), output);
  }
  
  // optional uint64 numeric_value = 4;
  if (has_numeric_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->numeric_value(), output);
  }
  
  // optional bytes string_value = 5;
  if (has_string_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      5, this->string_value(), output);
  }
  
  // repeated bytes terms = 6;
  for (int i = 0; i < this->terms_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      6, this->terms(i), output);
  }
  
  // optional uint32 suffix_len = 10;
  if (has_suffix_len()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->suffix_len(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StoreIndexField::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required uint32 field_id = 1;
  if (has_field_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->field_id(), target);
  }
  
  // required uint32 field_flag = 2;
  if (has_field_flag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->field_flag(), target);
  }
  
  // required uint32 field_type = 3;
  if (has_field_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->field_type(), target);
  }
  
  // optional uint64 numeric_value = 4;
  if (has_numeric_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->numeric_value(), target);
  }
  
  // optional bytes string_value = 5;
  if (has_string_value()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        5, this->string_value(), target);
  }
  
  // repeated bytes terms = 6;
  for (int i = 0; i < this->terms_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBytesToArray(6, this->terms(i), target);
  }
  
  // optional uint32 suffix_len = 10;
  if (has_suffix_len()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->suffix_len(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StoreIndexField::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 field_id = 1;
    if (has_field_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->field_id());
    }
    
    // required uint32 field_flag = 2;
    if (has_field_flag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->field_flag());
    }
    
    // required uint32 field_type = 3;
    if (has_field_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->field_type());
    }
    
    // optional uint64 numeric_value = 4;
    if (has_numeric_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->numeric_value());
    }
    
    // optional bytes string_value = 5;
    if (has_string_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->string_value());
    }
    
    // optional uint32 suffix_len = 10;
    if (has_suffix_len()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->suffix_len());
    }
    
  }
  // repeated bytes terms = 6;
  total_size += 1 * this->terms_size();
  for (int i = 0; i < this->terms_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->terms(i));
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StoreIndexField::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StoreIndexField* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StoreIndexField*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StoreIndexField::MergeFrom(const StoreIndexField& from) {
  GOOGLE_CHECK_NE(&from, this);
  terms_.MergeFrom(from.terms_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_field_id()) {
      set_field_id(from.field_id());
    }
    if (from.has_field_flag()) {
      set_field_flag(from.field_flag());
    }
    if (from.has_field_type()) {
      set_field_type(from.field_type());
    }
    if (from.has_numeric_value()) {
      set_numeric_value(from.numeric_value());
    }
    if (from.has_string_value()) {
      set_string_value(from.string_value());
    }
    if (from.has_suffix_len()) {
      set_suffix_len(from.suffix_len());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StoreIndexField::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StoreIndexField::CopyFrom(const StoreIndexField& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StoreIndexField::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  
  return true;
}

void StoreIndexField::Swap(StoreIndexField* other) {
  if (other != this) {
    std::swap(field_id_, other->field_id_);
    std::swap(field_flag_, other->field_flag_);
    std::swap(field_type_, other->field_type_);
    std::swap(numeric_value_, other->numeric_value_);
    std::swap(string_value_, other->string_value_);
    terms_.Swap(&other->terms_);
    std::swap(suffix_len_, other->suffix_len_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StoreIndexField::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StoreIndexField_descriptor_;
  metadata.reflection = StoreIndexField_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StoreDocument::kDocumentIdFieldNumber;
const int StoreDocument::kFieldsFieldNumber;
#endif  // !_MSC_VER

StoreDocument::StoreDocument()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StoreDocument::InitAsDefaultInstance() {
}

StoreDocument::StoreDocument(const StoreDocument& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StoreDocument::SharedCtor() {
  _cached_size_ = 0;
  document_id_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StoreDocument::~StoreDocument() {
  SharedDtor();
}

void StoreDocument::SharedDtor() {
  if (this != default_instance_) {
  }
}

void StoreDocument::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StoreDocument::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StoreDocument_descriptor_;
}

const StoreDocument& StoreDocument::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

StoreDocument* StoreDocument::default_instance_ = NULL;

StoreDocument* StoreDocument::New() const {
  return new StoreDocument;
}

void StoreDocument::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    document_id_ = GOOGLE_ULONGLONG(0);
  }
  fields_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StoreDocument::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 document_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &document_id_)));
          set_has_document_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_fields;
        break;
      }
      
      // repeated .lsmsearch.StoreIndexField fields = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_fields:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_fields()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_fields;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StoreDocument::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint64 document_id = 1;
  if (has_document_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->document_id(), output);
  }
  
  // repeated .lsmsearch.StoreIndexField fields = 2;
  for (int i = 0; i < this->fields_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->fields(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StoreDocument::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required uint64 document_id = 1;
  if (has_document_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->document_id(), target);
  }
  
  // repeated .lsmsearch.StoreIndexField fields = 2;
  for (int i = 0; i < this->fields_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->fields(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StoreDocument::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint64 document_id = 1;
    if (has_document_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->document_id());
    }
    
  }
  // repeated .lsmsearch.StoreIndexField fields = 2;
  total_size += 1 * this->fields_size();
  for (int i = 0; i < this->fields_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->fields(i));
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StoreDocument::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StoreDocument* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StoreDocument*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StoreDocument::MergeFrom(const StoreDocument& from) {
  GOOGLE_CHECK_NE(&from, this);
  fields_.MergeFrom(from.fields_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_document_id()) {
      set_document_id(from.document_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StoreDocument::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StoreDocument::CopyFrom(const StoreDocument& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StoreDocument::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  for (int i = 0; i < fields_size(); i++) {
    if (!this->fields(i).IsInitialized()) return false;
  }
  return true;
}

void StoreDocument::Swap(StoreDocument* other) {
  if (other != this) {
    std::swap(document_id_, other->document_id_);
    fields_.Swap(&other->fields_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StoreDocument::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StoreDocument_descriptor_;
  metadata.reflection = StoreDocument_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StoreDocValue::kFieldsFieldNumber;
#endif  // !_MSC_VER

StoreDocValue::StoreDocValue()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StoreDocValue::InitAsDefaultInstance() {
}

StoreDocValue::StoreDocValue(const StoreDocValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StoreDocValue::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StoreDocValue::~StoreDocValue() {
  SharedDtor();
}

void StoreDocValue::SharedDtor() {
  if (this != default_instance_) {
  }
}

void StoreDocValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StoreDocValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StoreDocValue_descriptor_;
}

const StoreDocValue& StoreDocValue::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

StoreDocValue* StoreDocValue::default_instance_ = NULL;

StoreDocValue* StoreDocValue::New() const {
  return new StoreDocValue;
}

void StoreDocValue::Clear() {
  fields_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StoreDocValue::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .lsmsearch.StoreIndexField fields = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_fields:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_fields()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_fields;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StoreDocValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .lsmsearch.StoreIndexField fields = 1;
  for (int i = 0; i < this->fields_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->fields(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StoreDocValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .lsmsearch.StoreIndexField fields = 1;
  for (int i = 0; i < this->fields_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->fields(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StoreDocValue::ByteSize() const {
  int total_size = 0;
  
  // repeated .lsmsearch.StoreIndexField fields = 1;
  total_size += 1 * this->fields_size();
  for (int i = 0; i < this->fields_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->fields(i));
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StoreDocValue::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StoreDocValue* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StoreDocValue*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StoreDocValue::MergeFrom(const StoreDocValue& from) {
  GOOGLE_CHECK_NE(&from, this);
  fields_.MergeFrom(from.fields_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StoreDocValue::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StoreDocValue::CopyFrom(const StoreDocValue& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StoreDocValue::IsInitialized() const {
  
  for (int i = 0; i < fields_size(); i++) {
    if (!this->fields(i).IsInitialized()) return false;
  }
  return true;
}

void StoreDocValue::Swap(StoreDocValue* other) {
  if (other != this) {
    fields_.Swap(&other->fields_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StoreDocValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StoreDocValue_descriptor_;
  metadata.reflection = StoreDocValue_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int StoreMeta::kTotalDocumentsFieldNumber;
const int StoreMeta::kDeleteDocumentsFieldNumber;
const int StoreMeta::kIncreaseSeqFieldNumber;
const int StoreMeta::kTermsCountFieldNumber;
#endif  // !_MSC_VER

StoreMeta::StoreMeta()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void StoreMeta::InitAsDefaultInstance() {
}

StoreMeta::StoreMeta(const StoreMeta& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void StoreMeta::SharedCtor() {
  _cached_size_ = 0;
  total_documents_ = GOOGLE_ULONGLONG(0);
  delete_documents_ = GOOGLE_ULONGLONG(0);
  increase_seq_ = GOOGLE_ULONGLONG(0);
  terms_count_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StoreMeta::~StoreMeta() {
  SharedDtor();
}

void StoreMeta::SharedDtor() {
  if (this != default_instance_) {
  }
}

void StoreMeta::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* StoreMeta::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return StoreMeta_descriptor_;
}

const StoreMeta& StoreMeta::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

StoreMeta* StoreMeta::default_instance_ = NULL;

StoreMeta* StoreMeta::New() const {
  return new StoreMeta;
}

void StoreMeta::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    total_documents_ = GOOGLE_ULONGLONG(0);
    delete_documents_ = GOOGLE_ULONGLONG(0);
    increase_seq_ = GOOGLE_ULONGLONG(0);
    terms_count_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool StoreMeta::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 total_documents = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &total_documents_)));
          set_has_total_documents();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_delete_documents;
        break;
      }
      
      // optional uint64 delete_documents = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_delete_documents:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &delete_documents_)));
          set_has_delete_documents();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_increase_seq;
        break;
      }
      
      // optional uint64 increase_seq = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_increase_seq:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &increase_seq_)));
          set_has_increase_seq();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_terms_count;
        break;
      }
      
      // optional uint64 terms_count = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_terms_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &terms_count_)));
          set_has_terms_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void StoreMeta::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional uint64 total_documents = 1;
  if (has_total_documents()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->total_documents(), output);
  }
  
  // optional uint64 delete_documents = 2;
  if (has_delete_documents()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->delete_documents(), output);
  }
  
  // optional uint64 increase_seq = 3;
  if (has_increase_seq()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->increase_seq(), output);
  }
  
  // optional uint64 terms_count = 4;
  if (has_terms_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->terms_count(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* StoreMeta::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional uint64 total_documents = 1;
  if (has_total_documents()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->total_documents(), target);
  }
  
  // optional uint64 delete_documents = 2;
  if (has_delete_documents()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->delete_documents(), target);
  }
  
  // optional uint64 increase_seq = 3;
  if (has_increase_seq()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->increase_seq(), target);
  }
  
  // optional uint64 terms_count = 4;
  if (has_terms_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->terms_count(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int StoreMeta::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint64 total_documents = 1;
    if (has_total_documents()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->total_documents());
    }
    
    // optional uint64 delete_documents = 2;
    if (has_delete_documents()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->delete_documents());
    }
    
    // optional uint64 increase_seq = 3;
    if (has_increase_seq()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->increase_seq());
    }
    
    // optional uint64 terms_count = 4;
    if (has_terms_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->terms_count());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StoreMeta::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const StoreMeta* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const StoreMeta*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void StoreMeta::MergeFrom(const StoreMeta& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_total_documents()) {
      set_total_documents(from.total_documents());
    }
    if (from.has_delete_documents()) {
      set_delete_documents(from.delete_documents());
    }
    if (from.has_increase_seq()) {
      set_increase_seq(from.increase_seq());
    }
    if (from.has_terms_count()) {
      set_terms_count(from.terms_count());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void StoreMeta::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void StoreMeta::CopyFrom(const StoreMeta& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StoreMeta::IsInitialized() const {
  
  return true;
}

void StoreMeta::Swap(StoreMeta* other) {
  if (other != this) {
    std::swap(total_documents_, other->total_documents_);
    std::swap(delete_documents_, other->delete_documents_);
    std::swap(increase_seq_, other->increase_seq_);
    std::swap(terms_count_, other->terms_count_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata StoreMeta::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = StoreMeta_descriptor_;
  metadata.reflection = StoreMeta_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* MockData_Type_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MockData_Type_descriptor_;
}
bool MockData_Type_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const MockData_Type MockData::kUnknown;
const MockData_Type MockData::kUpdate;
const MockData_Type MockData::kMerge;
const MockData_Type MockData::kDelete;
const MockData_Type MockData::kDeleteRange;
const MockData_Type MockData::Type_MIN;
const MockData_Type MockData::Type_MAX;
const int MockData::Type_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int MockData::kColumnTypeFieldNumber;
const int MockData::kKeyFieldNumber;
const int MockData::kValueFieldNumber;
const int MockData::kTypeFieldNumber;
const int MockData::kEndKeyFieldNumber;
#endif  // !_MSC_VER

MockData::MockData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void MockData::InitAsDefaultInstance() {
}

MockData::MockData(const MockData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void MockData::SharedCtor() {
  _cached_size_ = 0;
  column_type_ = 0u;
  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  type_ = 0;
  end_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MockData::~MockData() {
  SharedDtor();
}

void MockData::SharedDtor() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (end_key_ != &::google::protobuf::internal::kEmptyString) {
    delete end_key_;
  }
  if (this != default_instance_) {
  }
}

void MockData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MockData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MockData_descriptor_;
}

const MockData& MockData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

MockData* MockData::default_instance_ = NULL;

MockData* MockData::New() const {
  return new MockData;
}

void MockData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    column_type_ = 0u;
    if (has_key()) {
      if (key_ != &::google::protobuf::internal::kEmptyString) {
        key_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::kEmptyString) {
        value_->clear();
      }
    }
    type_ = 0;
    if (has_end_key()) {
      if (end_key_ != &::google::protobuf::internal::kEmptyString) {
        end_key_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MockData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 column_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &column_type_)));
          set_has_column_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_key;
        break;
      }
      
      // required bytes key = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_key:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_key()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_value;
        break;
      }
      
      // required bytes value = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_value()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_type;
        break;
      }
      
      // required .lsmsearch.MockData.Type type = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::lsmsearch::MockData_Type_IsValid(value)) {
            set_type(static_cast< ::lsmsearch::MockData_Type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_end_key;
        break;
      }
      
      // optional bytes end_key = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_end_key:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_end_key()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void MockData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 column_type = 1;
  if (has_column_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->column_type(), output);
  }
  
  // required bytes key = 2;
  if (has_key()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->key(), output);
  }
  
  // required bytes value = 3;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      3, this->value(), output);
  }
  
  // required .lsmsearch.MockData.Type type = 4;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->type(), output);
  }
  
  // optional bytes end_key = 5;
  if (has_end_key()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      5, this->end_key(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* MockData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required uint32 column_type = 1;
  if (has_column_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->column_type(), target);
  }
  
  // required bytes key = 2;
  if (has_key()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->key(), target);
  }
  
  // required bytes value = 3;
  if (has_value()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        3, this->value(), target);
  }
  
  // required .lsmsearch.MockData.Type type = 4;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->type(), target);
  }
  
  // optional bytes end_key = 5;
  if (has_end_key()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        5, this->end_key(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int MockData::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 column_type = 1;
    if (has_column_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->column_type());
    }
    
    // required bytes key = 2;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->key());
    }
    
    // required bytes value = 3;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->value());
    }
    
    // required .lsmsearch.MockData.Type type = 4;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }
    
    // optional bytes end_key = 5;
    if (has_end_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->end_key());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MockData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MockData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MockData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MockData::MergeFrom(const MockData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_column_type()) {
      set_column_type(from.column_type());
    }
    if (from.has_key()) {
      set_key(from.key());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_end_key()) {
      set_end_key(from.end_key());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MockData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MockData::CopyFrom(const MockData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MockData::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
  
  return true;
}

void MockData::Swap(MockData* other) {
  if (other != this) {
    std::swap(column_type_, other->column_type_);
    std::swap(key_, other->key_);
    std::swap(value_, other->value_);
    std::swap(type_, other->type_);
    std::swap(end_key_, other->end_key_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MockData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MockData_descriptor_;
  metadata.reflection = MockData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int MockDataList::kMockDataListFieldNumber;
#endif  // !_MSC_VER

MockDataList::MockDataList()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void MockDataList::InitAsDefaultInstance() {
}

MockDataList::MockDataList(const MockDataList& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void MockDataList::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MockDataList::~MockDataList() {
  SharedDtor();
}

void MockDataList::SharedDtor() {
  if (this != default_instance_) {
  }
}

void MockDataList::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* MockDataList::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MockDataList_descriptor_;
}

const MockDataList& MockDataList::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_search_5fstore_2eproto();  return *default_instance_;
}

MockDataList* MockDataList::default_instance_ = NULL;

MockDataList* MockDataList::New() const {
  return new MockDataList;
}

void MockDataList::Clear() {
  mock_data_list_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool MockDataList::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .lsmsearch.MockData mock_data_list = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_mock_data_list:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_mock_data_list()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_mock_data_list;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void MockDataList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .lsmsearch.MockData mock_data_list = 1;
  for (int i = 0; i < this->mock_data_list_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->mock_data_list(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* MockDataList::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .lsmsearch.MockData mock_data_list = 1;
  for (int i = 0; i < this->mock_data_list_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->mock_data_list(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int MockDataList::ByteSize() const {
  int total_size = 0;
  
  // repeated .lsmsearch.MockData mock_data_list = 1;
  total_size += 1 * this->mock_data_list_size();
  for (int i = 0; i < this->mock_data_list_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->mock_data_list(i));
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MockDataList::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const MockDataList* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const MockDataList*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void MockDataList::MergeFrom(const MockDataList& from) {
  GOOGLE_CHECK_NE(&from, this);
  mock_data_list_.MergeFrom(from.mock_data_list_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void MockDataList::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MockDataList::CopyFrom(const MockDataList& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MockDataList::IsInitialized() const {
  
  for (int i = 0; i < mock_data_list_size(); i++) {
    if (!this->mock_data_list(i).IsInitialized()) return false;
  }
  return true;
}

void MockDataList::Swap(MockDataList* other) {
  if (other != this) {
    mock_data_list_.Swap(&other->mock_data_list_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata MockDataList::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MockDataList_descriptor_;
  metadata.reflection = MockDataList_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace lsmsearch

// @@protoc_insertion_point(global_scope)