/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/generated/IndexMessages.pb.cc

Go to the documentation of this file.

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "IndexMessages.pb.h"
#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>

namespace aitools {
namespace invertedindex {

namespace {

const ::google::protobuf::Descriptor* Configuration_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Configuration_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* Configuration_InputFormat_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* Configuration_Sorting_descriptor_ = NULL;
const ::google::protobuf::Descriptor* Header_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Header_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_IndexMessages_2eproto() {
  protobuf_AddDesc_IndexMessages_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "IndexMessages.proto");
  GOOGLE_CHECK(file != NULL);
  Configuration_descriptor_ = file->message_type(0);
  static const int Configuration_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, input_directory_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, index_directory_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, available_memory_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, postlist_sorting_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, input_format_),
  };
  Configuration_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Configuration_descriptor_,
      Configuration::default_instance_,
      Configuration_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Configuration));
  Configuration_InputFormat_descriptor_ = Configuration_descriptor_->enum_type(0);
  Configuration_Sorting_descriptor_ = Configuration_descriptor_->enum_type(1);
  Header_descriptor_ = file->message_type(1);
  static const int Header_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, payload_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, key_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, value_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, minor_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, major_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, indexing_duration_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, value_class_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, postlist_sorting_),
  };
  Header_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Header_descriptor_,
      Header::default_instance_,
      Header_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Header));
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Configuration_descriptor_, &Configuration::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Header_descriptor_, &Header::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_IndexMessages_2eproto() {
  delete Configuration::default_instance_;
  delete Configuration_reflection_;
  delete Header::default_instance_;
  delete Header_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\023IndexMessages.proto\022\025aitools.invertedi"
    "ndex\"\373\002\n\rConfiguration\022\027\n\017input_director"
    "y\030\001 \001(\t\022\027\n\017index_directory\030\002 \001(\t\022\036\n\020avai"
    "lable_memory\030\003 \001(\r:\0042000\022P\n\020postlist_sor"
    "ting\030\004 \001(\0162,.aitools.invertedindex.Confi"
    "guration.Sorting:\010DISABLED\022W\n\014input_form"
    "at\030\005 \001(\01620.aitools.invertedindex.Configu"
    "ration.InputFormat:\017PSEUDO_INVERTED\"5\n\013I"
    "nputFormat\022\021\n\rREAL_INVERTED\020\000\022\023\n\017PSEUDO_"
    "INVERTED\020\001\"6\n\007Sorting\022\014\n\010DISABLED\020\000\022\r\n\tA"
    "SCENDING\020\001\022\016\n\nDESCENDING\020\002\"\354\001\n\006Header\022\017\n"
    "\007payload\030\001 \001(\003\022\021\n\tkey_count\030\002 \001(\003\022\023\n\013val"
    "ue_count\030\003 \001(\003\022\025\n\rminor_version\030\004 \001(\005\022\025\n"
    "\rmajor_version\030\005 \001(\005\022\031\n\021indexing_duratio"
    "n\030\006 \001(\005\022\030\n\020value_class_name\030\007 \001(\t\022F\n\020pos"
    "tlist_sorting\030\010 \001(\0162,.aitools.invertedin"
    "dex.Configuration.SortingB)\n%de.aitools."
    "aq.invertedindex.generatedH\001", 708);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "IndexMessages.proto", &protobuf_RegisterTypes);
  Configuration::default_instance_ = new Configuration();
  Header::default_instance_ = new Header();
  Configuration::default_instance_->InitAsDefaultInstance();
  Header::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_IndexMessages_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_IndexMessages_2eproto {
  StaticDescriptorInitializer_IndexMessages_2eproto() {
    protobuf_AddDesc_IndexMessages_2eproto();
  }
} static_descriptor_initializer_IndexMessages_2eproto_;


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

const ::google::protobuf::EnumDescriptor* Configuration_InputFormat_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Configuration_InputFormat_descriptor_;
}
bool Configuration_InputFormat_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const Configuration_InputFormat Configuration::REAL_INVERTED;
const Configuration_InputFormat Configuration::PSEUDO_INVERTED;
const Configuration_InputFormat Configuration::InputFormat_MIN;
const Configuration_InputFormat Configuration::InputFormat_MAX;
#endif  // _MSC_VER
const ::google::protobuf::EnumDescriptor* Configuration_Sorting_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Configuration_Sorting_descriptor_;
}
bool Configuration_Sorting_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const Configuration_Sorting Configuration::DISABLED;
const Configuration_Sorting Configuration::ASCENDING;
const Configuration_Sorting Configuration::DESCENDING;
const Configuration_Sorting Configuration::Sorting_MIN;
const Configuration_Sorting Configuration::Sorting_MAX;
#endif  // _MSC_VER
const ::std::string Configuration::_default_input_directory_;
const ::std::string Configuration::_default_index_directory_;
#ifndef _MSC_VER
const int Configuration::kInputDirectoryFieldNumber;
const int Configuration::kIndexDirectoryFieldNumber;
const int Configuration::kAvailableMemoryFieldNumber;
const int Configuration::kPostlistSortingFieldNumber;
const int Configuration::kInputFormatFieldNumber;
#endif  // !_MSC_VER

Configuration::Configuration() {
  SharedCtor();
}

void Configuration::InitAsDefaultInstance() {
}

Configuration::Configuration(const Configuration& from) {
  SharedCtor();
  MergeFrom(from);
}

void Configuration::SharedCtor() {
  _cached_size_ = 0;
  input_directory_ = const_cast< ::std::string*>(&_default_input_directory_);
  index_directory_ = const_cast< ::std::string*>(&_default_index_directory_);
  available_memory_ = 2000u;
  postlist_sorting_ = 0;
  input_format_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void Configuration::SharedDtor() {
  if (input_directory_ != &_default_input_directory_) {
    delete input_directory_;
  }
  if (index_directory_ != &_default_index_directory_) {
    delete index_directory_;
  }
  if (this != default_instance_) {
  }
}

const ::google::protobuf::Descriptor* Configuration::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Configuration_descriptor_;
}

const Configuration& Configuration::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_IndexMessages_2eproto();  return *default_instance_;
}

Configuration* Configuration::default_instance_ = NULL;

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

void Configuration::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (_has_bit(0)) {
      if (input_directory_ != &_default_input_directory_) {
        input_directory_->clear();
      }
    }
    if (_has_bit(1)) {
      if (index_directory_ != &_default_index_directory_) {
        index_directory_->clear();
      }
    }
    available_memory_ = 2000u;
    postlist_sorting_ = 0;
    input_format_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Configuration::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 string input_directory = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          goto handle_uninterpreted;
        }
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
              input, this->mutable_input_directory()));
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
          this->input_directory().data(), this->input_directory().length(),
          ::google::protobuf::internal::WireFormat::PARSE);
        if (input->ExpectTag(18)) goto parse_index_directory;
        break;
      }
      
      // optional string index_directory = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          goto handle_uninterpreted;
        }
       parse_index_directory:
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
              input, this->mutable_index_directory()));
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
          this->index_directory().data(), this->index_directory().length(),
          ::google::protobuf::internal::WireFormat::PARSE);
        if (input->ExpectTag(24)) goto parse_available_memory;
        break;
      }
      
      // optional uint32 available_memory = 3 [default = 2000];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_available_memory:
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
              input, &available_memory_));
        _set_bit(2);
        if (input->ExpectTag(32)) goto parse_postlist_sorting;
        break;
      }
      
      // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 4 [default = DISABLED];
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_postlist_sorting:
        int value;
        DO_(::google::protobuf::internal::WireFormatLite::ReadEnum(input, &value));
        if (::aitools::invertedindex::Configuration_Sorting_IsValid(value)) {
          set_postlist_sorting(static_cast< ::aitools::invertedindex::Configuration_Sorting >(value));
        } else {
          mutable_unknown_fields()->AddVarint(4, value);
        }
        if (input->ExpectTag(40)) goto parse_input_format;
        break;
      }
      
      // optional .aitools.invertedindex.Configuration.InputFormat input_format = 5 [default = PSEUDO_INVERTED];
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_input_format:
        int value;
        DO_(::google::protobuf::internal::WireFormatLite::ReadEnum(input, &value));
        if (::aitools::invertedindex::Configuration_InputFormat_IsValid(value)) {
          set_input_format(static_cast< ::aitools::invertedindex::Configuration_InputFormat >(value));
        } else {
          mutable_unknown_fields()->AddVarint(5, value);
        }
        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 Configuration::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
  if (raw_buffer != NULL) {
    Configuration::SerializeWithCachedSizesToArray(raw_buffer);
    return;
  }
  
  // optional string input_directory = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->input_directory().data(), this->input_directory().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->input_directory(), output);
  }
  
  // optional string index_directory = 2;
  if (_has_bit(1)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->index_directory().data(), this->index_directory().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->index_directory(), output);
  }
  
  // optional uint32 available_memory = 3 [default = 2000];
  if (_has_bit(2)) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->available_memory(), output);
  }
  
  // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 4 [default = DISABLED];
  if (_has_bit(3)) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->postlist_sorting(), output);
  }
  
  // optional .aitools.invertedindex.Configuration.InputFormat input_format = 5 [default = PSEUDO_INVERTED];
  if (_has_bit(4)) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->input_format(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Configuration::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string input_directory = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->input_directory().data(), this->input_directory().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->input_directory(), target);
  }
  
  // optional string index_directory = 2;
  if (_has_bit(1)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->index_directory().data(), this->index_directory().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->index_directory(), target);
  }
  
  // optional uint32 available_memory = 3 [default = 2000];
  if (_has_bit(2)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->available_memory(), target);
  }
  
  // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 4 [default = DISABLED];
  if (_has_bit(3)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->postlist_sorting(), target);
  }
  
  // optional .aitools.invertedindex.Configuration.InputFormat input_format = 5 [default = PSEUDO_INVERTED];
  if (_has_bit(4)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->input_format(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Configuration::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional string input_directory = 1;
    if (has_input_directory()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->input_directory());
    }
    
    // optional string index_directory = 2;
    if (has_index_directory()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->index_directory());
    }
    
    // optional uint32 available_memory = 3 [default = 2000];
    if (has_available_memory()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->available_memory());
    }
    
    // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 4 [default = DISABLED];
    if (has_postlist_sorting()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->postlist_sorting());
    }
    
    // optional .aitools.invertedindex.Configuration.InputFormat input_format = 5 [default = PSEUDO_INVERTED];
    if (has_input_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->input_format());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  _cached_size_ = total_size;
  return total_size;
}

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

void Configuration::MergeFrom(const Configuration& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_input_directory(from.input_directory());
    }
    if (from._has_bit(1)) {
      set_index_directory(from.index_directory());
    }
    if (from._has_bit(2)) {
      set_available_memory(from.available_memory());
    }
    if (from._has_bit(3)) {
      set_postlist_sorting(from.postlist_sorting());
    }
    if (from._has_bit(4)) {
      set_input_format(from.input_format());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void Configuration::Swap(Configuration* other) {
  if (other != this) {
    std::swap(input_directory_, other->input_directory_);
    std::swap(index_directory_, other->index_directory_);
    std::swap(available_memory_, other->available_memory_);
    std::swap(postlist_sorting_, other->postlist_sorting_);
    std::swap(input_format_, other->input_format_);
    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 Configuration::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Configuration_descriptor_;
  metadata.reflection = Configuration_reflection_;
  return metadata;
}


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

const ::std::string Header::_default_value_class_name_;
#ifndef _MSC_VER
const int Header::kPayloadFieldNumber;
const int Header::kKeyCountFieldNumber;
const int Header::kValueCountFieldNumber;
const int Header::kMinorVersionFieldNumber;
const int Header::kMajorVersionFieldNumber;
const int Header::kIndexingDurationFieldNumber;
const int Header::kValueClassNameFieldNumber;
const int Header::kPostlistSortingFieldNumber;
#endif  // !_MSC_VER

Header::Header() {
  SharedCtor();
}

void Header::InitAsDefaultInstance() {
}

Header::Header(const Header& from) {
  SharedCtor();
  MergeFrom(from);
}

void Header::SharedCtor() {
  _cached_size_ = 0;
  payload_ = GOOGLE_LONGLONG(0);
  key_count_ = GOOGLE_LONGLONG(0);
  value_count_ = GOOGLE_LONGLONG(0);
  minor_version_ = 0;
  major_version_ = 0;
  indexing_duration_ = 0;
  value_class_name_ = const_cast< ::std::string*>(&_default_value_class_name_);
  postlist_sorting_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void Header::SharedDtor() {
  if (value_class_name_ != &_default_value_class_name_) {
    delete value_class_name_;
  }
  if (this != default_instance_) {
  }
}

const ::google::protobuf::Descriptor* Header::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Header_descriptor_;
}

const Header& Header::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_IndexMessages_2eproto();  return *default_instance_;
}

Header* Header::default_instance_ = NULL;

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

void Header::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    payload_ = GOOGLE_LONGLONG(0);
    key_count_ = GOOGLE_LONGLONG(0);
    value_count_ = GOOGLE_LONGLONG(0);
    minor_version_ = 0;
    major_version_ = 0;
    indexing_duration_ = 0;
    if (_has_bit(6)) {
      if (value_class_name_ != &_default_value_class_name_) {
        value_class_name_->clear();
      }
    }
    postlist_sorting_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Header::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 int64 payload = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt64(
              input, &payload_));
        _set_bit(0);
        if (input->ExpectTag(16)) goto parse_key_count;
        break;
      }
      
      // optional int64 key_count = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_key_count:
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt64(
              input, &key_count_));
        _set_bit(1);
        if (input->ExpectTag(24)) goto parse_value_count;
        break;
      }
      
      // optional int64 value_count = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_value_count:
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt64(
              input, &value_count_));
        _set_bit(2);
        if (input->ExpectTag(32)) goto parse_minor_version;
        break;
      }
      
      // optional int32 minor_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_minor_version:
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt32(
              input, &minor_version_));
        _set_bit(3);
        if (input->ExpectTag(40)) goto parse_major_version;
        break;
      }
      
      // optional int32 major_version = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_major_version:
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt32(
              input, &major_version_));
        _set_bit(4);
        if (input->ExpectTag(48)) goto parse_indexing_duration;
        break;
      }
      
      // optional int32 indexing_duration = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_indexing_duration:
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt32(
              input, &indexing_duration_));
        _set_bit(5);
        if (input->ExpectTag(58)) goto parse_value_class_name;
        break;
      }
      
      // optional string value_class_name = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          goto handle_uninterpreted;
        }
       parse_value_class_name:
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
              input, this->mutable_value_class_name()));
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
          this->value_class_name().data(), this->value_class_name().length(),
          ::google::protobuf::internal::WireFormat::PARSE);
        if (input->ExpectTag(64)) goto parse_postlist_sorting;
        break;
      }
      
      // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
       parse_postlist_sorting:
        int value;
        DO_(::google::protobuf::internal::WireFormatLite::ReadEnum(input, &value));
        if (::aitools::invertedindex::Configuration_Sorting_IsValid(value)) {
          set_postlist_sorting(static_cast< ::aitools::invertedindex::Configuration_Sorting >(value));
        } else {
          mutable_unknown_fields()->AddVarint(8, value);
        }
        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 Header::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
  if (raw_buffer != NULL) {
    Header::SerializeWithCachedSizesToArray(raw_buffer);
    return;
  }
  
  // optional int64 payload = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->payload(), output);
  }
  
  // optional int64 key_count = 2;
  if (_has_bit(1)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->key_count(), output);
  }
  
  // optional int64 value_count = 3;
  if (_has_bit(2)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->value_count(), output);
  }
  
  // optional int32 minor_version = 4;
  if (_has_bit(3)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->minor_version(), output);
  }
  
  // optional int32 major_version = 5;
  if (_has_bit(4)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->major_version(), output);
  }
  
  // optional int32 indexing_duration = 6;
  if (_has_bit(5)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->indexing_duration(), output);
  }
  
  // optional string value_class_name = 7;
  if (_has_bit(6)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value_class_name().data(), this->value_class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      7, this->value_class_name(), output);
  }
  
  // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 8;
  if (_has_bit(7)) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->postlist_sorting(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Header::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int64 payload = 1;
  if (_has_bit(0)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->payload(), target);
  }
  
  // optional int64 key_count = 2;
  if (_has_bit(1)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->key_count(), target);
  }
  
  // optional int64 value_count = 3;
  if (_has_bit(2)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->value_count(), target);
  }
  
  // optional int32 minor_version = 4;
  if (_has_bit(3)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->minor_version(), target);
  }
  
  // optional int32 major_version = 5;
  if (_has_bit(4)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->major_version(), target);
  }
  
  // optional int32 indexing_duration = 6;
  if (_has_bit(5)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->indexing_duration(), target);
  }
  
  // optional string value_class_name = 7;
  if (_has_bit(6)) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value_class_name().data(), this->value_class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        7, this->value_class_name(), target);
  }
  
  // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 8;
  if (_has_bit(7)) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->postlist_sorting(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Header::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int64 payload = 1;
    if (has_payload()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->payload());
    }
    
    // optional int64 key_count = 2;
    if (has_key_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->key_count());
    }
    
    // optional int64 value_count = 3;
    if (has_value_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->value_count());
    }
    
    // optional int32 minor_version = 4;
    if (has_minor_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->minor_version());
    }
    
    // optional int32 major_version = 5;
    if (has_major_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->major_version());
    }
    
    // optional int32 indexing_duration = 6;
    if (has_indexing_duration()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->indexing_duration());
    }
    
    // optional string value_class_name = 7;
    if (has_value_class_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value_class_name());
    }
    
    // optional .aitools.invertedindex.Configuration.Sorting postlist_sorting = 8;
    if (has_postlist_sorting()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->postlist_sorting());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  _cached_size_ = total_size;
  return total_size;
}

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

void Header::MergeFrom(const Header& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_payload(from.payload());
    }
    if (from._has_bit(1)) {
      set_key_count(from.key_count());
    }
    if (from._has_bit(2)) {
      set_value_count(from.value_count());
    }
    if (from._has_bit(3)) {
      set_minor_version(from.minor_version());
    }
    if (from._has_bit(4)) {
      set_major_version(from.major_version());
    }
    if (from._has_bit(5)) {
      set_indexing_duration(from.indexing_duration());
    }
    if (from._has_bit(6)) {
      set_value_class_name(from.value_class_name());
    }
    if (from._has_bit(7)) {
      set_postlist_sorting(from.postlist_sorting());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

void Header::Swap(Header* other) {
  if (other != this) {
    std::swap(payload_, other->payload_);
    std::swap(key_count_, other->key_count_);
    std::swap(value_count_, other->value_count_);
    std::swap(minor_version_, other->minor_version_);
    std::swap(major_version_, other->major_version_);
    std::swap(indexing_duration_, other->indexing_duration_);
    std::swap(value_class_name_, other->value_class_name_);
    std::swap(postlist_sorting_, other->postlist_sorting_);
    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 Header::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Header_descriptor_;
  metadata.reflection = Header_reflection_;
  return metadata;
}


}  // namespace invertedindex
}  // namespace aitools

---