config.pb.h

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

#ifndef PROTOBUF_config_2eproto__INCLUDED
#define PROTOBUF_config_2eproto__INCLUDED

#include <string>

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

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

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

namespace dmlc {
namespace lda {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_config_2eproto();
void protobuf_AssignDesc_config_2eproto();
void protobuf_ShutdownFile_config_2eproto();

class Config;

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

class Config : public ::google::protobuf::Message {
 public:
  Config();
  virtual ~Config();

  Config(const Config& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(Config* other);

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

  // optional string train_data = 1;
  inline bool has_train_data() const;
  inline void clear_train_data();
  static const int kTrainDataFieldNumber = 1;
  inline const ::std::string& train_data() const;
  inline void set_train_data(const ::std::string& value);
  inline void set_train_data(const char* value);
  inline void set_train_data(const char* value, size_t size);
  inline ::std::string* mutable_train_data();
  inline ::std::string* release_train_data();
  inline void set_allocated_train_data(::std::string* train_data);

  // optional string val_data = 2;
  inline bool has_val_data() const;
  inline void clear_val_data();
  static const int kValDataFieldNumber = 2;
  inline const ::std::string& val_data() const;
  inline void set_val_data(const ::std::string& value);
  inline void set_val_data(const char* value);
  inline void set_val_data(const char* value, size_t size);
  inline ::std::string* mutable_val_data();
  inline ::std::string* release_val_data();
  inline void set_allocated_val_data(::std::string* val_data);

  // optional string data_format = 4 [default = "libsvm"];
  inline bool has_data_format() const;
  inline void clear_data_format();
  static const int kDataFormatFieldNumber = 4;
  inline const ::std::string& data_format() const;
  inline void set_data_format(const ::std::string& value);
  inline void set_data_format(const char* value);
  inline void set_data_format(const char* value, size_t size);
  inline ::std::string* mutable_data_format();
  inline ::std::string* release_data_format();
  inline void set_allocated_data_format(::std::string* data_format);

  // optional string model_out = 5;
  inline bool has_model_out() const;
  inline void clear_model_out();
  static const int kModelOutFieldNumber = 5;
  inline const ::std::string& model_out() const;
  inline void set_model_out(const ::std::string& value);
  inline void set_model_out(const char* value);
  inline void set_model_out(const char* value, size_t size);
  inline ::std::string* mutable_model_out();
  inline ::std::string* release_model_out();
  inline void set_allocated_model_out(::std::string* model_out);

  // optional string model_in = 7;
  inline bool has_model_in() const;
  inline void clear_model_in();
  static const int kModelInFieldNumber = 7;
  inline const ::std::string& model_in() const;
  inline void set_model_in(const ::std::string& value);
  inline void set_model_in(const char* value);
  inline void set_model_in(const char* value, size_t size);
  inline ::std::string* mutable_model_in();
  inline ::std::string* release_model_in();
  inline void set_allocated_model_in(::std::string* model_in);

  // optional float alpha = 9;
  inline bool has_alpha() const;
  inline void clear_alpha();
  static const int kAlphaFieldNumber = 9;
  inline float alpha() const;
  inline void set_alpha(float value);

  // optional float beta = 10;
  inline bool has_beta() const;
  inline void clear_beta();
  static const int kBetaFieldNumber = 10;
  inline float beta() const;
  inline void set_beta(float value);

  // optional int32 topic_num = 11;
  inline bool has_topic_num() const;
  inline void clear_topic_num();
  static const int kTopicNumFieldNumber = 11;
  inline ::google::protobuf::int32 topic_num() const;
  inline void set_topic_num(::google::protobuf::int32 value);

  // optional int32 words_num = 12;
  inline bool has_words_num() const;
  inline void clear_words_num();
  static const int kWordsNumFieldNumber = 12;
  inline ::google::protobuf::int32 words_num() const;
  inline void set_words_num(::google::protobuf::int32 value);

  // optional string predict_out = 13;
  inline bool has_predict_out() const;
  inline void clear_predict_out();
  static const int kPredictOutFieldNumber = 13;
  inline const ::std::string& predict_out() const;
  inline void set_predict_out(const ::std::string& value);
  inline void set_predict_out(const char* value);
  inline void set_predict_out(const char* value, size_t size);
  inline ::std::string* mutable_predict_out();
  inline ::std::string* release_predict_out();
  inline void set_allocated_predict_out(::std::string* predict_out);

  // optional int32 minibatch = 22 [default = 1000];
  inline bool has_minibatch() const;
  inline void clear_minibatch();
  static const int kMinibatchFieldNumber = 22;
  inline ::google::protobuf::int32 minibatch() const;
  inline void set_minibatch(::google::protobuf::int32 value);

  // optional int32 max_data_pass = 23 [default = 10];
  inline bool has_max_data_pass() const;
  inline void clear_max_data_pass();
  static const int kMaxDataPassFieldNumber = 23;
  inline ::google::protobuf::int32 max_data_pass() const;
  inline void set_max_data_pass(::google::protobuf::int32 value);

  // optional int32 save_iter = 6 [default = -1];
  inline bool has_save_iter() const;
  inline void clear_save_iter();
  static const int kSaveIterFieldNumber = 6;
  inline ::google::protobuf::int32 save_iter() const;
  inline void set_save_iter(::google::protobuf::int32 value);

  // optional int32 load_iter = 8 [default = -1];
  inline bool has_load_iter() const;
  inline void clear_load_iter();
  static const int kLoadIterFieldNumber = 8;
  inline ::google::protobuf::int32 load_iter() const;
  inline void set_load_iter(::google::protobuf::int32 value);

  // optional bool local_data = 101 [default = false];
  inline bool has_local_data() const;
  inline void clear_local_data();
  static const int kLocalDataFieldNumber = 101;
  inline bool local_data() const;
  inline void set_local_data(bool value);

  // optional int32 num_parts_per_file = 102 [default = 2];
  inline bool has_num_parts_per_file() const;
  inline void clear_num_parts_per_file();
  static const int kNumPartsPerFileFieldNumber = 102;
  inline ::google::protobuf::int32 num_parts_per_file() const;
  inline void set_num_parts_per_file(::google::protobuf::int32 value);

  // optional float print_sec = 111 [default = 1];
  inline bool has_print_sec() const;
  inline void clear_print_sec();
  static const int kPrintSecFieldNumber = 111;
  inline float print_sec() const;
  inline void set_print_sec(float value);

  // optional int32 num_threads = 121 [default = 2];
  inline bool has_num_threads() const;
  inline void clear_num_threads();
  static const int kNumThreadsFieldNumber = 121;
  inline ::google::protobuf::int32 num_threads() const;
  inline void set_num_threads(::google::protobuf::int32 value);

  // optional int32 max_concurrency = 122 [default = 2];
  inline bool has_max_concurrency() const;
  inline void clear_max_concurrency();
  static const int kMaxConcurrencyFieldNumber = 122;
  inline ::google::protobuf::int32 max_concurrency() const;
  inline void set_max_concurrency(::google::protobuf::int32 value);

  // optional bool key_cache = 123 [default = true];
  inline bool has_key_cache() const;
  inline void clear_key_cache();
  static const int kKeyCacheFieldNumber = 123;
  inline bool key_cache() const;
  inline void set_key_cache(bool value);

  // optional bool msg_compression = 124 [default = true];
  inline bool has_msg_compression() const;
  inline void clear_msg_compression();
  static const int kMsgCompressionFieldNumber = 124;
  inline bool msg_compression() const;
  inline void set_msg_compression(bool value);

  // optional int32 fixed_bytes = 125 [default = 0];
  inline bool has_fixed_bytes() const;
  inline void clear_fixed_bytes();
  static const int kFixedBytesFieldNumber = 125;
  inline ::google::protobuf::int32 fixed_bytes() const;
  inline void set_fixed_bytes(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:dmlc.lda.Config)
 private:
  inline void set_has_train_data();
  inline void clear_has_train_data();
  inline void set_has_val_data();
  inline void clear_has_val_data();
  inline void set_has_data_format();
  inline void clear_has_data_format();
  inline void set_has_model_out();
  inline void clear_has_model_out();
  inline void set_has_model_in();
  inline void clear_has_model_in();
  inline void set_has_alpha();
  inline void clear_has_alpha();
  inline void set_has_beta();
  inline void clear_has_beta();
  inline void set_has_topic_num();
  inline void clear_has_topic_num();
  inline void set_has_words_num();
  inline void clear_has_words_num();
  inline void set_has_predict_out();
  inline void clear_has_predict_out();
  inline void set_has_minibatch();
  inline void clear_has_minibatch();
  inline void set_has_max_data_pass();
  inline void clear_has_max_data_pass();
  inline void set_has_save_iter();
  inline void clear_has_save_iter();
  inline void set_has_load_iter();
  inline void clear_has_load_iter();
  inline void set_has_local_data();
  inline void clear_has_local_data();
  inline void set_has_num_parts_per_file();
  inline void clear_has_num_parts_per_file();
  inline void set_has_print_sec();
  inline void clear_has_print_sec();
  inline void set_has_num_threads();
  inline void clear_has_num_threads();
  inline void set_has_max_concurrency();
  inline void clear_has_max_concurrency();
  inline void set_has_key_cache();
  inline void clear_has_key_cache();
  inline void set_has_msg_compression();
  inline void clear_has_msg_compression();
  inline void set_has_fixed_bytes();
  inline void clear_has_fixed_bytes();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* train_data_;
  ::std::string* val_data_;
  ::std::string* data_format_;
  static ::std::string* _default_data_format_;
  ::std::string* model_out_;
  ::std::string* model_in_;
  float alpha_;
  float beta_;
  ::google::protobuf::int32 topic_num_;
  ::google::protobuf::int32 words_num_;
  ::std::string* predict_out_;
  ::google::protobuf::int32 minibatch_;
  ::google::protobuf::int32 max_data_pass_;
  ::google::protobuf::int32 save_iter_;
  ::google::protobuf::int32 load_iter_;
  ::google::protobuf::int32 num_parts_per_file_;
  float print_sec_;
  ::google::protobuf::int32 num_threads_;
  bool local_data_;
  bool key_cache_;
  bool msg_compression_;
  ::google::protobuf::int32 max_concurrency_;
  ::google::protobuf::int32 fixed_bytes_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(22 + 31) / 32];

  friend void  protobuf_AddDesc_config_2eproto();
  friend void protobuf_AssignDesc_config_2eproto();
  friend void protobuf_ShutdownFile_config_2eproto();

  void InitAsDefaultInstance();
  static Config* default_instance_;
};
// ===================================================================


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

// Config

// optional string train_data = 1;
inline bool Config::has_train_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Config::set_has_train_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Config::clear_has_train_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Config::clear_train_data() {
  if (train_data_ != &::google::protobuf::internal::kEmptyString) {
    train_data_->clear();
  }
  clear_has_train_data();
}
inline const ::std::string& Config::train_data() const {
  return *train_data_;
}
inline void Config::set_train_data(const ::std::string& value) {
  set_has_train_data();
  if (train_data_ == &::google::protobuf::internal::kEmptyString) {
    train_data_ = new ::std::string;
  }
  train_data_->assign(value);
}
inline void Config::set_train_data(const char* value) {
  set_has_train_data();
  if (train_data_ == &::google::protobuf::internal::kEmptyString) {
    train_data_ = new ::std::string;
  }
  train_data_->assign(value);
}
inline void Config::set_train_data(const char* value, size_t size) {
  set_has_train_data();
  if (train_data_ == &::google::protobuf::internal::kEmptyString) {
    train_data_ = new ::std::string;
  }
  train_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_train_data() {
  set_has_train_data();
  if (train_data_ == &::google::protobuf::internal::kEmptyString) {
    train_data_ = new ::std::string;
  }
  return train_data_;
}
inline ::std::string* Config::release_train_data() {
  clear_has_train_data();
  if (train_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = train_data_;
    train_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Config::set_allocated_train_data(::std::string* train_data) {
  if (train_data_ != &::google::protobuf::internal::kEmptyString) {
    delete train_data_;
  }
  if (train_data) {
    set_has_train_data();
    train_data_ = train_data;
  } else {
    clear_has_train_data();
    train_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string val_data = 2;
inline bool Config::has_val_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Config::set_has_val_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Config::clear_has_val_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Config::clear_val_data() {
  if (val_data_ != &::google::protobuf::internal::kEmptyString) {
    val_data_->clear();
  }
  clear_has_val_data();
}
inline const ::std::string& Config::val_data() const {
  return *val_data_;
}
inline void Config::set_val_data(const ::std::string& value) {
  set_has_val_data();
  if (val_data_ == &::google::protobuf::internal::kEmptyString) {
    val_data_ = new ::std::string;
  }
  val_data_->assign(value);
}
inline void Config::set_val_data(const char* value) {
  set_has_val_data();
  if (val_data_ == &::google::protobuf::internal::kEmptyString) {
    val_data_ = new ::std::string;
  }
  val_data_->assign(value);
}
inline void Config::set_val_data(const char* value, size_t size) {
  set_has_val_data();
  if (val_data_ == &::google::protobuf::internal::kEmptyString) {
    val_data_ = new ::std::string;
  }
  val_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_val_data() {
  set_has_val_data();
  if (val_data_ == &::google::protobuf::internal::kEmptyString) {
    val_data_ = new ::std::string;
  }
  return val_data_;
}
inline ::std::string* Config::release_val_data() {
  clear_has_val_data();
  if (val_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = val_data_;
    val_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Config::set_allocated_val_data(::std::string* val_data) {
  if (val_data_ != &::google::protobuf::internal::kEmptyString) {
    delete val_data_;
  }
  if (val_data) {
    set_has_val_data();
    val_data_ = val_data;
  } else {
    clear_has_val_data();
    val_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string data_format = 4 [default = "libsvm"];
inline bool Config::has_data_format() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Config::set_has_data_format() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Config::clear_has_data_format() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Config::clear_data_format() {
  if (data_format_ != _default_data_format_) {
    data_format_->assign(*_default_data_format_);
  }
  clear_has_data_format();
}
inline const ::std::string& Config::data_format() const {
  return *data_format_;
}
inline void Config::set_data_format(const ::std::string& value) {
  set_has_data_format();
  if (data_format_ == _default_data_format_) {
    data_format_ = new ::std::string;
  }
  data_format_->assign(value);
}
inline void Config::set_data_format(const char* value) {
  set_has_data_format();
  if (data_format_ == _default_data_format_) {
    data_format_ = new ::std::string;
  }
  data_format_->assign(value);
}
inline void Config::set_data_format(const char* value, size_t size) {
  set_has_data_format();
  if (data_format_ == _default_data_format_) {
    data_format_ = new ::std::string;
  }
  data_format_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_data_format() {
  set_has_data_format();
  if (data_format_ == _default_data_format_) {
    data_format_ = new ::std::string(*_default_data_format_);
  }
  return data_format_;
}
inline ::std::string* Config::release_data_format() {
  clear_has_data_format();
  if (data_format_ == _default_data_format_) {
    return NULL;
  } else {
    ::std::string* temp = data_format_;
    data_format_ = const_cast< ::std::string*>(_default_data_format_);
    return temp;
  }
}
inline void Config::set_allocated_data_format(::std::string* data_format) {
  if (data_format_ != _default_data_format_) {
    delete data_format_;
  }
  if (data_format) {
    set_has_data_format();
    data_format_ = data_format;
  } else {
    clear_has_data_format();
    data_format_ = const_cast< ::std::string*>(_default_data_format_);
  }
}

// optional string model_out = 5;
inline bool Config::has_model_out() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Config::set_has_model_out() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Config::clear_has_model_out() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Config::clear_model_out() {
  if (model_out_ != &::google::protobuf::internal::kEmptyString) {
    model_out_->clear();
  }
  clear_has_model_out();
}
inline const ::std::string& Config::model_out() const {
  return *model_out_;
}
inline void Config::set_model_out(const ::std::string& value) {
  set_has_model_out();
  if (model_out_ == &::google::protobuf::internal::kEmptyString) {
    model_out_ = new ::std::string;
  }
  model_out_->assign(value);
}
inline void Config::set_model_out(const char* value) {
  set_has_model_out();
  if (model_out_ == &::google::protobuf::internal::kEmptyString) {
    model_out_ = new ::std::string;
  }
  model_out_->assign(value);
}
inline void Config::set_model_out(const char* value, size_t size) {
  set_has_model_out();
  if (model_out_ == &::google::protobuf::internal::kEmptyString) {
    model_out_ = new ::std::string;
  }
  model_out_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_model_out() {
  set_has_model_out();
  if (model_out_ == &::google::protobuf::internal::kEmptyString) {
    model_out_ = new ::std::string;
  }
  return model_out_;
}
inline ::std::string* Config::release_model_out() {
  clear_has_model_out();
  if (model_out_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = model_out_;
    model_out_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Config::set_allocated_model_out(::std::string* model_out) {
  if (model_out_ != &::google::protobuf::internal::kEmptyString) {
    delete model_out_;
  }
  if (model_out) {
    set_has_model_out();
    model_out_ = model_out;
  } else {
    clear_has_model_out();
    model_out_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string model_in = 7;
inline bool Config::has_model_in() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Config::set_has_model_in() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Config::clear_has_model_in() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Config::clear_model_in() {
  if (model_in_ != &::google::protobuf::internal::kEmptyString) {
    model_in_->clear();
  }
  clear_has_model_in();
}
inline const ::std::string& Config::model_in() const {
  return *model_in_;
}
inline void Config::set_model_in(const ::std::string& value) {
  set_has_model_in();
  if (model_in_ == &::google::protobuf::internal::kEmptyString) {
    model_in_ = new ::std::string;
  }
  model_in_->assign(value);
}
inline void Config::set_model_in(const char* value) {
  set_has_model_in();
  if (model_in_ == &::google::protobuf::internal::kEmptyString) {
    model_in_ = new ::std::string;
  }
  model_in_->assign(value);
}
inline void Config::set_model_in(const char* value, size_t size) {
  set_has_model_in();
  if (model_in_ == &::google::protobuf::internal::kEmptyString) {
    model_in_ = new ::std::string;
  }
  model_in_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_model_in() {
  set_has_model_in();
  if (model_in_ == &::google::protobuf::internal::kEmptyString) {
    model_in_ = new ::std::string;
  }
  return model_in_;
}
inline ::std::string* Config::release_model_in() {
  clear_has_model_in();
  if (model_in_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = model_in_;
    model_in_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Config::set_allocated_model_in(::std::string* model_in) {
  if (model_in_ != &::google::protobuf::internal::kEmptyString) {
    delete model_in_;
  }
  if (model_in) {
    set_has_model_in();
    model_in_ = model_in;
  } else {
    clear_has_model_in();
    model_in_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional float alpha = 9;
inline bool Config::has_alpha() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Config::set_has_alpha() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Config::clear_has_alpha() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Config::clear_alpha() {
  alpha_ = 0;
  clear_has_alpha();
}
inline float Config::alpha() const {
  return alpha_;
}
inline void Config::set_alpha(float value) {
  set_has_alpha();
  alpha_ = value;
}

// optional float beta = 10;
inline bool Config::has_beta() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Config::set_has_beta() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Config::clear_has_beta() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Config::clear_beta() {
  beta_ = 0;
  clear_has_beta();
}
inline float Config::beta() const {
  return beta_;
}
inline void Config::set_beta(float value) {
  set_has_beta();
  beta_ = value;
}

// optional int32 topic_num = 11;
inline bool Config::has_topic_num() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Config::set_has_topic_num() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Config::clear_has_topic_num() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Config::clear_topic_num() {
  topic_num_ = 0;
  clear_has_topic_num();
}
inline ::google::protobuf::int32 Config::topic_num() const {
  return topic_num_;
}
inline void Config::set_topic_num(::google::protobuf::int32 value) {
  set_has_topic_num();
  topic_num_ = value;
}

// optional int32 words_num = 12;
inline bool Config::has_words_num() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Config::set_has_words_num() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Config::clear_has_words_num() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Config::clear_words_num() {
  words_num_ = 0;
  clear_has_words_num();
}
inline ::google::protobuf::int32 Config::words_num() const {
  return words_num_;
}
inline void Config::set_words_num(::google::protobuf::int32 value) {
  set_has_words_num();
  words_num_ = value;
}

// optional string predict_out = 13;
inline bool Config::has_predict_out() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Config::set_has_predict_out() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Config::clear_has_predict_out() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Config::clear_predict_out() {
  if (predict_out_ != &::google::protobuf::internal::kEmptyString) {
    predict_out_->clear();
  }
  clear_has_predict_out();
}
inline const ::std::string& Config::predict_out() const {
  return *predict_out_;
}
inline void Config::set_predict_out(const ::std::string& value) {
  set_has_predict_out();
  if (predict_out_ == &::google::protobuf::internal::kEmptyString) {
    predict_out_ = new ::std::string;
  }
  predict_out_->assign(value);
}
inline void Config::set_predict_out(const char* value) {
  set_has_predict_out();
  if (predict_out_ == &::google::protobuf::internal::kEmptyString) {
    predict_out_ = new ::std::string;
  }
  predict_out_->assign(value);
}
inline void Config::set_predict_out(const char* value, size_t size) {
  set_has_predict_out();
  if (predict_out_ == &::google::protobuf::internal::kEmptyString) {
    predict_out_ = new ::std::string;
  }
  predict_out_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Config::mutable_predict_out() {
  set_has_predict_out();
  if (predict_out_ == &::google::protobuf::internal::kEmptyString) {
    predict_out_ = new ::std::string;
  }
  return predict_out_;
}
inline ::std::string* Config::release_predict_out() {
  clear_has_predict_out();
  if (predict_out_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = predict_out_;
    predict_out_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Config::set_allocated_predict_out(::std::string* predict_out) {
  if (predict_out_ != &::google::protobuf::internal::kEmptyString) {
    delete predict_out_;
  }
  if (predict_out) {
    set_has_predict_out();
    predict_out_ = predict_out;
  } else {
    clear_has_predict_out();
    predict_out_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 minibatch = 22 [default = 1000];
inline bool Config::has_minibatch() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Config::set_has_minibatch() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Config::clear_has_minibatch() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Config::clear_minibatch() {
  minibatch_ = 1000;
  clear_has_minibatch();
}
inline ::google::protobuf::int32 Config::minibatch() const {
  return minibatch_;
}
inline void Config::set_minibatch(::google::protobuf::int32 value) {
  set_has_minibatch();
  minibatch_ = value;
}

// optional int32 max_data_pass = 23 [default = 10];
inline bool Config::has_max_data_pass() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Config::set_has_max_data_pass() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Config::clear_has_max_data_pass() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Config::clear_max_data_pass() {
  max_data_pass_ = 10;
  clear_has_max_data_pass();
}
inline ::google::protobuf::int32 Config::max_data_pass() const {
  return max_data_pass_;
}
inline void Config::set_max_data_pass(::google::protobuf::int32 value) {
  set_has_max_data_pass();
  max_data_pass_ = value;
}

// optional int32 save_iter = 6 [default = -1];
inline bool Config::has_save_iter() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Config::set_has_save_iter() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Config::clear_has_save_iter() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Config::clear_save_iter() {
  save_iter_ = -1;
  clear_has_save_iter();
}
inline ::google::protobuf::int32 Config::save_iter() const {
  return save_iter_;
}
inline void Config::set_save_iter(::google::protobuf::int32 value) {
  set_has_save_iter();
  save_iter_ = value;
}

// optional int32 load_iter = 8 [default = -1];
inline bool Config::has_load_iter() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Config::set_has_load_iter() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Config::clear_has_load_iter() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Config::clear_load_iter() {
  load_iter_ = -1;
  clear_has_load_iter();
}
inline ::google::protobuf::int32 Config::load_iter() const {
  return load_iter_;
}
inline void Config::set_load_iter(::google::protobuf::int32 value) {
  set_has_load_iter();
  load_iter_ = value;
}

// optional bool local_data = 101 [default = false];
inline bool Config::has_local_data() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Config::set_has_local_data() {
  _has_bits_[0] |= 0x00004000u;
}
inline void Config::clear_has_local_data() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void Config::clear_local_data() {
  local_data_ = false;
  clear_has_local_data();
}
inline bool Config::local_data() const {
  return local_data_;
}
inline void Config::set_local_data(bool value) {
  set_has_local_data();
  local_data_ = value;
}

// optional int32 num_parts_per_file = 102 [default = 2];
inline bool Config::has_num_parts_per_file() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Config::set_has_num_parts_per_file() {
  _has_bits_[0] |= 0x00008000u;
}
inline void Config::clear_has_num_parts_per_file() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void Config::clear_num_parts_per_file() {
  num_parts_per_file_ = 2;
  clear_has_num_parts_per_file();
}
inline ::google::protobuf::int32 Config::num_parts_per_file() const {
  return num_parts_per_file_;
}
inline void Config::set_num_parts_per_file(::google::protobuf::int32 value) {
  set_has_num_parts_per_file();
  num_parts_per_file_ = value;
}

// optional float print_sec = 111 [default = 1];
inline bool Config::has_print_sec() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void Config::set_has_print_sec() {
  _has_bits_[0] |= 0x00010000u;
}
inline void Config::clear_has_print_sec() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void Config::clear_print_sec() {
  print_sec_ = 1;
  clear_has_print_sec();
}
inline float Config::print_sec() const {
  return print_sec_;
}
inline void Config::set_print_sec(float value) {
  set_has_print_sec();
  print_sec_ = value;
}

// optional int32 num_threads = 121 [default = 2];
inline bool Config::has_num_threads() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void Config::set_has_num_threads() {
  _has_bits_[0] |= 0x00020000u;
}
inline void Config::clear_has_num_threads() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void Config::clear_num_threads() {
  num_threads_ = 2;
  clear_has_num_threads();
}
inline ::google::protobuf::int32 Config::num_threads() const {
  return num_threads_;
}
inline void Config::set_num_threads(::google::protobuf::int32 value) {
  set_has_num_threads();
  num_threads_ = value;
}

// optional int32 max_concurrency = 122 [default = 2];
inline bool Config::has_max_concurrency() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void Config::set_has_max_concurrency() {
  _has_bits_[0] |= 0x00040000u;
}
inline void Config::clear_has_max_concurrency() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void Config::clear_max_concurrency() {
  max_concurrency_ = 2;
  clear_has_max_concurrency();
}
inline ::google::protobuf::int32 Config::max_concurrency() const {
  return max_concurrency_;
}
inline void Config::set_max_concurrency(::google::protobuf::int32 value) {
  set_has_max_concurrency();
  max_concurrency_ = value;
}

// optional bool key_cache = 123 [default = true];
inline bool Config::has_key_cache() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void Config::set_has_key_cache() {
  _has_bits_[0] |= 0x00080000u;
}
inline void Config::clear_has_key_cache() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void Config::clear_key_cache() {
  key_cache_ = true;
  clear_has_key_cache();
}
inline bool Config::key_cache() const {
  return key_cache_;
}
inline void Config::set_key_cache(bool value) {
  set_has_key_cache();
  key_cache_ = value;
}

// optional bool msg_compression = 124 [default = true];
inline bool Config::has_msg_compression() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void Config::set_has_msg_compression() {
  _has_bits_[0] |= 0x00100000u;
}
inline void Config::clear_has_msg_compression() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void Config::clear_msg_compression() {
  msg_compression_ = true;
  clear_has_msg_compression();
}
inline bool Config::msg_compression() const {
  return msg_compression_;
}
inline void Config::set_msg_compression(bool value) {
  set_has_msg_compression();
  msg_compression_ = value;
}

// optional int32 fixed_bytes = 125 [default = 0];
inline bool Config::has_fixed_bytes() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void Config::set_has_fixed_bytes() {
  _has_bits_[0] |= 0x00200000u;
}
inline void Config::clear_has_fixed_bytes() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void Config::clear_fixed_bytes() {
  fixed_bytes_ = 0;
  clear_has_fixed_bytes();
}
inline ::google::protobuf::int32 Config::fixed_bytes() const {
  return fixed_bytes_;
}
inline void Config::set_fixed_bytes(::google::protobuf::int32 value) {
  set_has_fixed_bytes();
  fixed_bytes_ = value;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace lda
}  // namespace dmlc

#ifndef SWIG
namespace google {
namespace protobuf {


}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_config_2eproto__INCLUDED