// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: object_detection/protos/input_reader.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2finput_5freader_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2finput_5freader_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021005 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_object_5fdetection_2fprotos_2finput_5freader_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_object_5fdetection_2fprotos_2finput_5freader_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_object_5fdetection_2fprotos_2finput_5freader_2eproto;
namespace object_detection {
namespace protos {
class ExternalInputReader;
struct ExternalInputReaderDefaultTypeInternal;
extern ExternalInputReaderDefaultTypeInternal _ExternalInputReader_default_instance_;
class InputReader;
struct InputReaderDefaultTypeInternal;
extern InputReaderDefaultTypeInternal _InputReader_default_instance_;
class TFRecordInputReader;
struct TFRecordInputReaderDefaultTypeInternal;
extern TFRecordInputReaderDefaultTypeInternal _TFRecordInputReader_default_instance_;
}  // namespace protos
}  // namespace object_detection
PROTOBUF_NAMESPACE_OPEN
template<> ::object_detection::protos::ExternalInputReader* Arena::CreateMaybeMessage<::object_detection::protos::ExternalInputReader>(Arena*);
template<> ::object_detection::protos::InputReader* Arena::CreateMaybeMessage<::object_detection::protos::InputReader>(Arena*);
template<> ::object_detection::protos::TFRecordInputReader* Arena::CreateMaybeMessage<::object_detection::protos::TFRecordInputReader>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace object_detection {
namespace protos {

enum InstanceMaskType : int {
  DEFAULT = 0,
  NUMERICAL_MASKS = 1,
  PNG_MASKS = 2
};
bool InstanceMaskType_IsValid(int value);
constexpr InstanceMaskType InstanceMaskType_MIN = DEFAULT;
constexpr InstanceMaskType InstanceMaskType_MAX = PNG_MASKS;
constexpr int InstanceMaskType_ARRAYSIZE = InstanceMaskType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* InstanceMaskType_descriptor();
template<typename T>
inline const std::string& InstanceMaskType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, InstanceMaskType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function InstanceMaskType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    InstanceMaskType_descriptor(), enum_t_value);
}
inline bool InstanceMaskType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InstanceMaskType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<InstanceMaskType>(
    InstanceMaskType_descriptor(), name, value);
}
// ===================================================================

class InputReader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.InputReader) */ {
 public:
  inline InputReader() : InputReader(nullptr) {}
  ~InputReader() override;
  explicit PROTOBUF_CONSTEXPR InputReader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  InputReader(const InputReader& from);
  InputReader(InputReader&& from) noexcept
    : InputReader() {
    *this = ::std::move(from);
  }

  inline InputReader& operator=(const InputReader& from) {
    CopyFrom(from);
    return *this;
  }
  inline InputReader& operator=(InputReader&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InputReader& default_instance() {
    return *internal_default_instance();
  }
  enum InputReaderCase {
    kTfRecordInputReader = 8,
    kExternalInputReader = 9,
    INPUT_READER_NOT_SET = 0,
  };

  static inline const InputReader* internal_default_instance() {
    return reinterpret_cast<const InputReader*>(
               &_InputReader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(InputReader& a, InputReader& b) {
    a.Swap(&b);
  }
  inline void Swap(InputReader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InputReader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InputReader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InputReader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InputReader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InputReader& from) {
    InputReader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InputReader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.InputReader";
  }
  protected:
  explicit InputReader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLabelMapPathFieldNumber = 1,
    kNameFieldNumber = 23,
    kNumEpochsFieldNumber = 5,
    kNumKeypointsFieldNumber = 16,
    kLoadMulticlassScoresFieldNumber = 24,
    kLoadInstanceMasksFieldNumber = 7,
    kUseDisplayNameFieldNumber = 17,
    kNumAdditionalChannelsFieldNumber = 18,
    kShuffleFieldNumber = 2,
    kQueueCapacityFieldNumber = 3,
    kMinAfterDequeueFieldNumber = 4,
    kNumReadersFieldNumber = 6,
    kMaskTypeFieldNumber = 10,
    kShuffleBufferSizeFieldNumber = 11,
    kFilenamesShuffleBufferSizeFieldNumber = 12,
    kPrefetchSizeFieldNumber = 13,
    kNumParallelMapCallsFieldNumber = 14,
    kReadBlockLengthFieldNumber = 15,
    kNumParallelBatchesFieldNumber = 19,
    kNumPrefetchBatchesFieldNumber = 20,
    kMaxNumberOfBoxesFieldNumber = 21,
    kSample1OfNExamplesFieldNumber = 22,
    kTfRecordInputReaderFieldNumber = 8,
    kExternalInputReaderFieldNumber = 9,
  };
  // optional string label_map_path = 1 [default = ""];
  bool has_label_map_path() const;
  private:
  bool _internal_has_label_map_path() const;
  public:
  void clear_label_map_path();
  const std::string& label_map_path() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_label_map_path(ArgT0&& arg0, ArgT... args);
  std::string* mutable_label_map_path();
  PROTOBUF_NODISCARD std::string* release_label_map_path();
  void set_allocated_label_map_path(std::string* label_map_path);
  private:
  const std::string& _internal_label_map_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_label_map_path(const std::string& value);
  std::string* _internal_mutable_label_map_path();
  public:

  // optional string name = 23 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional uint32 num_epochs = 5 [default = 0];
  bool has_num_epochs() const;
  private:
  bool _internal_has_num_epochs() const;
  public:
  void clear_num_epochs();
  uint32_t num_epochs() const;
  void set_num_epochs(uint32_t value);
  private:
  uint32_t _internal_num_epochs() const;
  void _internal_set_num_epochs(uint32_t value);
  public:

  // optional uint32 num_keypoints = 16 [default = 0];
  bool has_num_keypoints() const;
  private:
  bool _internal_has_num_keypoints() const;
  public:
  void clear_num_keypoints();
  uint32_t num_keypoints() const;
  void set_num_keypoints(uint32_t value);
  private:
  uint32_t _internal_num_keypoints() const;
  void _internal_set_num_keypoints(uint32_t value);
  public:

  // optional bool load_multiclass_scores = 24 [default = false];
  bool has_load_multiclass_scores() const;
  private:
  bool _internal_has_load_multiclass_scores() const;
  public:
  void clear_load_multiclass_scores();
  bool load_multiclass_scores() const;
  void set_load_multiclass_scores(bool value);
  private:
  bool _internal_load_multiclass_scores() const;
  void _internal_set_load_multiclass_scores(bool value);
  public:

  // optional bool load_instance_masks = 7 [default = false];
  bool has_load_instance_masks() const;
  private:
  bool _internal_has_load_instance_masks() const;
  public:
  void clear_load_instance_masks();
  bool load_instance_masks() const;
  void set_load_instance_masks(bool value);
  private:
  bool _internal_load_instance_masks() const;
  void _internal_set_load_instance_masks(bool value);
  public:

  // optional bool use_display_name = 17 [default = false];
  bool has_use_display_name() const;
  private:
  bool _internal_has_use_display_name() const;
  public:
  void clear_use_display_name();
  bool use_display_name() const;
  void set_use_display_name(bool value);
  private:
  bool _internal_use_display_name() const;
  void _internal_set_use_display_name(bool value);
  public:

  // optional int32 num_additional_channels = 18 [default = 0];
  bool has_num_additional_channels() const;
  private:
  bool _internal_has_num_additional_channels() const;
  public:
  void clear_num_additional_channels();
  int32_t num_additional_channels() const;
  void set_num_additional_channels(int32_t value);
  private:
  int32_t _internal_num_additional_channels() const;
  void _internal_set_num_additional_channels(int32_t value);
  public:

  // optional bool shuffle = 2 [default = true];
  bool has_shuffle() const;
  private:
  bool _internal_has_shuffle() const;
  public:
  void clear_shuffle();
  bool shuffle() const;
  void set_shuffle(bool value);
  private:
  bool _internal_shuffle() const;
  void _internal_set_shuffle(bool value);
  public:

  // optional uint32 queue_capacity = 3 [default = 2000, deprecated = true];
  PROTOBUF_DEPRECATED bool has_queue_capacity() const;
  private:
  bool _internal_has_queue_capacity() const;
  public:
  PROTOBUF_DEPRECATED void clear_queue_capacity();
  PROTOBUF_DEPRECATED uint32_t queue_capacity() const;
  PROTOBUF_DEPRECATED void set_queue_capacity(uint32_t value);
  private:
  uint32_t _internal_queue_capacity() const;
  void _internal_set_queue_capacity(uint32_t value);
  public:

  // optional uint32 min_after_dequeue = 4 [default = 1000, deprecated = true];
  PROTOBUF_DEPRECATED bool has_min_after_dequeue() const;
  private:
  bool _internal_has_min_after_dequeue() const;
  public:
  PROTOBUF_DEPRECATED void clear_min_after_dequeue();
  PROTOBUF_DEPRECATED uint32_t min_after_dequeue() const;
  PROTOBUF_DEPRECATED void set_min_after_dequeue(uint32_t value);
  private:
  uint32_t _internal_min_after_dequeue() const;
  void _internal_set_min_after_dequeue(uint32_t value);
  public:

  // optional uint32 num_readers = 6 [default = 64];
  bool has_num_readers() const;
  private:
  bool _internal_has_num_readers() const;
  public:
  void clear_num_readers();
  uint32_t num_readers() const;
  void set_num_readers(uint32_t value);
  private:
  uint32_t _internal_num_readers() const;
  void _internal_set_num_readers(uint32_t value);
  public:

  // optional .object_detection.protos.InstanceMaskType mask_type = 10 [default = NUMERICAL_MASKS];
  bool has_mask_type() const;
  private:
  bool _internal_has_mask_type() const;
  public:
  void clear_mask_type();
  ::object_detection::protos::InstanceMaskType mask_type() const;
  void set_mask_type(::object_detection::protos::InstanceMaskType value);
  private:
  ::object_detection::protos::InstanceMaskType _internal_mask_type() const;
  void _internal_set_mask_type(::object_detection::protos::InstanceMaskType value);
  public:

  // optional uint32 shuffle_buffer_size = 11 [default = 2048];
  bool has_shuffle_buffer_size() const;
  private:
  bool _internal_has_shuffle_buffer_size() const;
  public:
  void clear_shuffle_buffer_size();
  uint32_t shuffle_buffer_size() const;
  void set_shuffle_buffer_size(uint32_t value);
  private:
  uint32_t _internal_shuffle_buffer_size() const;
  void _internal_set_shuffle_buffer_size(uint32_t value);
  public:

  // optional uint32 filenames_shuffle_buffer_size = 12 [default = 100];
  bool has_filenames_shuffle_buffer_size() const;
  private:
  bool _internal_has_filenames_shuffle_buffer_size() const;
  public:
  void clear_filenames_shuffle_buffer_size();
  uint32_t filenames_shuffle_buffer_size() const;
  void set_filenames_shuffle_buffer_size(uint32_t value);
  private:
  uint32_t _internal_filenames_shuffle_buffer_size() const;
  void _internal_set_filenames_shuffle_buffer_size(uint32_t value);
  public:

  // optional uint32 prefetch_size = 13 [default = 512, deprecated = true];
  PROTOBUF_DEPRECATED bool has_prefetch_size() const;
  private:
  bool _internal_has_prefetch_size() const;
  public:
  PROTOBUF_DEPRECATED void clear_prefetch_size();
  PROTOBUF_DEPRECATED uint32_t prefetch_size() const;
  PROTOBUF_DEPRECATED void set_prefetch_size(uint32_t value);
  private:
  uint32_t _internal_prefetch_size() const;
  void _internal_set_prefetch_size(uint32_t value);
  public:

  // optional uint32 num_parallel_map_calls = 14 [default = 64, deprecated = true];
  PROTOBUF_DEPRECATED bool has_num_parallel_map_calls() const;
  private:
  bool _internal_has_num_parallel_map_calls() const;
  public:
  PROTOBUF_DEPRECATED void clear_num_parallel_map_calls();
  PROTOBUF_DEPRECATED uint32_t num_parallel_map_calls() const;
  PROTOBUF_DEPRECATED void set_num_parallel_map_calls(uint32_t value);
  private:
  uint32_t _internal_num_parallel_map_calls() const;
  void _internal_set_num_parallel_map_calls(uint32_t value);
  public:

  // optional uint32 read_block_length = 15 [default = 32];
  bool has_read_block_length() const;
  private:
  bool _internal_has_read_block_length() const;
  public:
  void clear_read_block_length();
  uint32_t read_block_length() const;
  void set_read_block_length(uint32_t value);
  private:
  uint32_t _internal_read_block_length() const;
  void _internal_set_read_block_length(uint32_t value);
  public:

  // optional uint32 num_parallel_batches = 19 [default = 8];
  bool has_num_parallel_batches() const;
  private:
  bool _internal_has_num_parallel_batches() const;
  public:
  void clear_num_parallel_batches();
  uint32_t num_parallel_batches() const;
  void set_num_parallel_batches(uint32_t value);
  private:
  uint32_t _internal_num_parallel_batches() const;
  void _internal_set_num_parallel_batches(uint32_t value);
  public:

  // optional int32 num_prefetch_batches = 20 [default = 2];
  bool has_num_prefetch_batches() const;
  private:
  bool _internal_has_num_prefetch_batches() const;
  public:
  void clear_num_prefetch_batches();
  int32_t num_prefetch_batches() const;
  void set_num_prefetch_batches(int32_t value);
  private:
  int32_t _internal_num_prefetch_batches() const;
  void _internal_set_num_prefetch_batches(int32_t value);
  public:

  // optional int32 max_number_of_boxes = 21 [default = 100];
  bool has_max_number_of_boxes() const;
  private:
  bool _internal_has_max_number_of_boxes() const;
  public:
  void clear_max_number_of_boxes();
  int32_t max_number_of_boxes() const;
  void set_max_number_of_boxes(int32_t value);
  private:
  int32_t _internal_max_number_of_boxes() const;
  void _internal_set_max_number_of_boxes(int32_t value);
  public:

  // optional uint32 sample_1_of_n_examples = 22 [default = 1];
  bool has_sample_1_of_n_examples() const;
  private:
  bool _internal_has_sample_1_of_n_examples() const;
  public:
  void clear_sample_1_of_n_examples();
  uint32_t sample_1_of_n_examples() const;
  void set_sample_1_of_n_examples(uint32_t value);
  private:
  uint32_t _internal_sample_1_of_n_examples() const;
  void _internal_set_sample_1_of_n_examples(uint32_t value);
  public:

  // .object_detection.protos.TFRecordInputReader tf_record_input_reader = 8;
  bool has_tf_record_input_reader() const;
  private:
  bool _internal_has_tf_record_input_reader() const;
  public:
  void clear_tf_record_input_reader();
  const ::object_detection::protos::TFRecordInputReader& tf_record_input_reader() const;
  PROTOBUF_NODISCARD ::object_detection::protos::TFRecordInputReader* release_tf_record_input_reader();
  ::object_detection::protos::TFRecordInputReader* mutable_tf_record_input_reader();
  void set_allocated_tf_record_input_reader(::object_detection::protos::TFRecordInputReader* tf_record_input_reader);
  private:
  const ::object_detection::protos::TFRecordInputReader& _internal_tf_record_input_reader() const;
  ::object_detection::protos::TFRecordInputReader* _internal_mutable_tf_record_input_reader();
  public:
  void unsafe_arena_set_allocated_tf_record_input_reader(
      ::object_detection::protos::TFRecordInputReader* tf_record_input_reader);
  ::object_detection::protos::TFRecordInputReader* unsafe_arena_release_tf_record_input_reader();

  // .object_detection.protos.ExternalInputReader external_input_reader = 9;
  bool has_external_input_reader() const;
  private:
  bool _internal_has_external_input_reader() const;
  public:
  void clear_external_input_reader();
  const ::object_detection::protos::ExternalInputReader& external_input_reader() const;
  PROTOBUF_NODISCARD ::object_detection::protos::ExternalInputReader* release_external_input_reader();
  ::object_detection::protos::ExternalInputReader* mutable_external_input_reader();
  void set_allocated_external_input_reader(::object_detection::protos::ExternalInputReader* external_input_reader);
  private:
  const ::object_detection::protos::ExternalInputReader& _internal_external_input_reader() const;
  ::object_detection::protos::ExternalInputReader* _internal_mutable_external_input_reader();
  public:
  void unsafe_arena_set_allocated_external_input_reader(
      ::object_detection::protos::ExternalInputReader* external_input_reader);
  ::object_detection::protos::ExternalInputReader* unsafe_arena_release_external_input_reader();

  void clear_input_reader();
  InputReaderCase input_reader_case() const;
  // @@protoc_insertion_point(class_scope:object_detection.protos.InputReader)
 private:
  class _Internal;
  void set_has_tf_record_input_reader();
  void set_has_external_input_reader();

  inline bool has_input_reader() const;
  inline void clear_has_input_reader();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr label_map_path_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    uint32_t num_epochs_;
    uint32_t num_keypoints_;
    bool load_multiclass_scores_;
    bool load_instance_masks_;
    bool use_display_name_;
    int32_t num_additional_channels_;
    bool shuffle_;
    uint32_t queue_capacity_;
    uint32_t min_after_dequeue_;
    uint32_t num_readers_;
    int mask_type_;
    uint32_t shuffle_buffer_size_;
    uint32_t filenames_shuffle_buffer_size_;
    uint32_t prefetch_size_;
    uint32_t num_parallel_map_calls_;
    uint32_t read_block_length_;
    uint32_t num_parallel_batches_;
    int32_t num_prefetch_batches_;
    int32_t max_number_of_boxes_;
    uint32_t sample_1_of_n_examples_;
    union InputReaderUnion {
      constexpr InputReaderUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::object_detection::protos::TFRecordInputReader* tf_record_input_reader_;
      ::object_detection::protos::ExternalInputReader* external_input_reader_;
    } input_reader_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2finput_5freader_2eproto;
};
// -------------------------------------------------------------------

class TFRecordInputReader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.TFRecordInputReader) */ {
 public:
  inline TFRecordInputReader() : TFRecordInputReader(nullptr) {}
  ~TFRecordInputReader() override;
  explicit PROTOBUF_CONSTEXPR TFRecordInputReader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TFRecordInputReader(const TFRecordInputReader& from);
  TFRecordInputReader(TFRecordInputReader&& from) noexcept
    : TFRecordInputReader() {
    *this = ::std::move(from);
  }

  inline TFRecordInputReader& operator=(const TFRecordInputReader& from) {
    CopyFrom(from);
    return *this;
  }
  inline TFRecordInputReader& operator=(TFRecordInputReader&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TFRecordInputReader& default_instance() {
    return *internal_default_instance();
  }
  static inline const TFRecordInputReader* internal_default_instance() {
    return reinterpret_cast<const TFRecordInputReader*>(
               &_TFRecordInputReader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(TFRecordInputReader& a, TFRecordInputReader& b) {
    a.Swap(&b);
  }
  inline void Swap(TFRecordInputReader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TFRecordInputReader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TFRecordInputReader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TFRecordInputReader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TFRecordInputReader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TFRecordInputReader& from) {
    TFRecordInputReader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TFRecordInputReader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.TFRecordInputReader";
  }
  protected:
  explicit TFRecordInputReader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kInputPathFieldNumber = 1,
  };
  // repeated string input_path = 1;
  int input_path_size() const;
  private:
  int _internal_input_path_size() const;
  public:
  void clear_input_path();
  const std::string& input_path(int index) const;
  std::string* mutable_input_path(int index);
  void set_input_path(int index, const std::string& value);
  void set_input_path(int index, std::string&& value);
  void set_input_path(int index, const char* value);
  void set_input_path(int index, const char* value, size_t size);
  std::string* add_input_path();
  void add_input_path(const std::string& value);
  void add_input_path(std::string&& value);
  void add_input_path(const char* value);
  void add_input_path(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input_path() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input_path();
  private:
  const std::string& _internal_input_path(int index) const;
  std::string* _internal_add_input_path();
  public:

  // @@protoc_insertion_point(class_scope:object_detection.protos.TFRecordInputReader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_path_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2finput_5freader_2eproto;
};
// -------------------------------------------------------------------

class ExternalInputReader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:object_detection.protos.ExternalInputReader) */ {
 public:
  inline ExternalInputReader() : ExternalInputReader(nullptr) {}
  ~ExternalInputReader() override;
  explicit PROTOBUF_CONSTEXPR ExternalInputReader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ExternalInputReader(const ExternalInputReader& from);
  ExternalInputReader(ExternalInputReader&& from) noexcept
    : ExternalInputReader() {
    *this = ::std::move(from);
  }

  inline ExternalInputReader& operator=(const ExternalInputReader& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExternalInputReader& operator=(ExternalInputReader&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ExternalInputReader& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExternalInputReader* internal_default_instance() {
    return reinterpret_cast<const ExternalInputReader*>(
               &_ExternalInputReader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ExternalInputReader& a, ExternalInputReader& b) {
    a.Swap(&b);
  }
  inline void Swap(ExternalInputReader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExternalInputReader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExternalInputReader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExternalInputReader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExternalInputReader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExternalInputReader& from) {
    ExternalInputReader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExternalInputReader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "object_detection.protos.ExternalInputReader";
  }
  protected:
  explicit ExternalInputReader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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


  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);

  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {

    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {

    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);

    return to_add;
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);

  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) const {

    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          ExternalInputReader, _proto_TypeTraits, _field_type, _is_packed>& id) {

    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }

  // @@protoc_insertion_point(class_scope:object_detection.protos.ExternalInputReader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_object_5fdetection_2fprotos_2finput_5freader_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// InputReader

// optional string name = 23 [default = ""];
inline bool InputReader::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool InputReader::has_name() const {
  return _internal_has_name();
}
inline void InputReader::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& InputReader::name() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputReader::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.name)
}
inline std::string* InputReader::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.InputReader.name)
  return _s;
}
inline const std::string& InputReader::_internal_name() const {
  return _impl_.name_.Get();
}
inline void InputReader::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* InputReader::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* InputReader::release_name() {
  // @@protoc_insertion_point(field_release:object_detection.protos.InputReader.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void InputReader::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.InputReader.name)
}

// optional string label_map_path = 1 [default = ""];
inline bool InputReader::_internal_has_label_map_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool InputReader::has_label_map_path() const {
  return _internal_has_label_map_path();
}
inline void InputReader::clear_label_map_path() {
  _impl_.label_map_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& InputReader::label_map_path() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.label_map_path)
  return _internal_label_map_path();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InputReader::set_label_map_path(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.label_map_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.label_map_path)
}
inline std::string* InputReader::mutable_label_map_path() {
  std::string* _s = _internal_mutable_label_map_path();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.InputReader.label_map_path)
  return _s;
}
inline const std::string& InputReader::_internal_label_map_path() const {
  return _impl_.label_map_path_.Get();
}
inline void InputReader::_internal_set_label_map_path(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.label_map_path_.Set(value, GetArenaForAllocation());
}
inline std::string* InputReader::_internal_mutable_label_map_path() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.label_map_path_.Mutable(GetArenaForAllocation());
}
inline std::string* InputReader::release_label_map_path() {
  // @@protoc_insertion_point(field_release:object_detection.protos.InputReader.label_map_path)
  if (!_internal_has_label_map_path()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.label_map_path_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.label_map_path_.IsDefault()) {
    _impl_.label_map_path_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void InputReader::set_allocated_label_map_path(std::string* label_map_path) {
  if (label_map_path != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.label_map_path_.SetAllocated(label_map_path, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.label_map_path_.IsDefault()) {
    _impl_.label_map_path_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:object_detection.protos.InputReader.label_map_path)
}

// optional bool shuffle = 2 [default = true];
inline bool InputReader::_internal_has_shuffle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool InputReader::has_shuffle() const {
  return _internal_has_shuffle();
}
inline void InputReader::clear_shuffle() {
  _impl_.shuffle_ = true;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool InputReader::_internal_shuffle() const {
  return _impl_.shuffle_;
}
inline bool InputReader::shuffle() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.shuffle)
  return _internal_shuffle();
}
inline void InputReader::_internal_set_shuffle(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.shuffle_ = value;
}
inline void InputReader::set_shuffle(bool value) {
  _internal_set_shuffle(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.shuffle)
}

// optional uint32 shuffle_buffer_size = 11 [default = 2048];
inline bool InputReader::_internal_has_shuffle_buffer_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool InputReader::has_shuffle_buffer_size() const {
  return _internal_has_shuffle_buffer_size();
}
inline void InputReader::clear_shuffle_buffer_size() {
  _impl_.shuffle_buffer_size_ = 2048u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t InputReader::_internal_shuffle_buffer_size() const {
  return _impl_.shuffle_buffer_size_;
}
inline uint32_t InputReader::shuffle_buffer_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.shuffle_buffer_size)
  return _internal_shuffle_buffer_size();
}
inline void InputReader::_internal_set_shuffle_buffer_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.shuffle_buffer_size_ = value;
}
inline void InputReader::set_shuffle_buffer_size(uint32_t value) {
  _internal_set_shuffle_buffer_size(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.shuffle_buffer_size)
}

// optional uint32 filenames_shuffle_buffer_size = 12 [default = 100];
inline bool InputReader::_internal_has_filenames_shuffle_buffer_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool InputReader::has_filenames_shuffle_buffer_size() const {
  return _internal_has_filenames_shuffle_buffer_size();
}
inline void InputReader::clear_filenames_shuffle_buffer_size() {
  _impl_.filenames_shuffle_buffer_size_ = 100u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t InputReader::_internal_filenames_shuffle_buffer_size() const {
  return _impl_.filenames_shuffle_buffer_size_;
}
inline uint32_t InputReader::filenames_shuffle_buffer_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.filenames_shuffle_buffer_size)
  return _internal_filenames_shuffle_buffer_size();
}
inline void InputReader::_internal_set_filenames_shuffle_buffer_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.filenames_shuffle_buffer_size_ = value;
}
inline void InputReader::set_filenames_shuffle_buffer_size(uint32_t value) {
  _internal_set_filenames_shuffle_buffer_size(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.filenames_shuffle_buffer_size)
}

// optional uint32 num_epochs = 5 [default = 0];
inline bool InputReader::_internal_has_num_epochs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool InputReader::has_num_epochs() const {
  return _internal_has_num_epochs();
}
inline void InputReader::clear_num_epochs() {
  _impl_.num_epochs_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t InputReader::_internal_num_epochs() const {
  return _impl_.num_epochs_;
}
inline uint32_t InputReader::num_epochs() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_epochs)
  return _internal_num_epochs();
}
inline void InputReader::_internal_set_num_epochs(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_epochs_ = value;
}
inline void InputReader::set_num_epochs(uint32_t value) {
  _internal_set_num_epochs(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_epochs)
}

// optional uint32 sample_1_of_n_examples = 22 [default = 1];
inline bool InputReader::_internal_has_sample_1_of_n_examples() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool InputReader::has_sample_1_of_n_examples() const {
  return _internal_has_sample_1_of_n_examples();
}
inline void InputReader::clear_sample_1_of_n_examples() {
  _impl_.sample_1_of_n_examples_ = 1u;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint32_t InputReader::_internal_sample_1_of_n_examples() const {
  return _impl_.sample_1_of_n_examples_;
}
inline uint32_t InputReader::sample_1_of_n_examples() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.sample_1_of_n_examples)
  return _internal_sample_1_of_n_examples();
}
inline void InputReader::_internal_set_sample_1_of_n_examples(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.sample_1_of_n_examples_ = value;
}
inline void InputReader::set_sample_1_of_n_examples(uint32_t value) {
  _internal_set_sample_1_of_n_examples(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.sample_1_of_n_examples)
}

// optional uint32 num_readers = 6 [default = 64];
inline bool InputReader::_internal_has_num_readers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool InputReader::has_num_readers() const {
  return _internal_has_num_readers();
}
inline void InputReader::clear_num_readers() {
  _impl_.num_readers_ = 64u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t InputReader::_internal_num_readers() const {
  return _impl_.num_readers_;
}
inline uint32_t InputReader::num_readers() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_readers)
  return _internal_num_readers();
}
inline void InputReader::_internal_set_num_readers(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.num_readers_ = value;
}
inline void InputReader::set_num_readers(uint32_t value) {
  _internal_set_num_readers(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_readers)
}

// optional uint32 num_parallel_batches = 19 [default = 8];
inline bool InputReader::_internal_has_num_parallel_batches() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool InputReader::has_num_parallel_batches() const {
  return _internal_has_num_parallel_batches();
}
inline void InputReader::clear_num_parallel_batches() {
  _impl_.num_parallel_batches_ = 8u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t InputReader::_internal_num_parallel_batches() const {
  return _impl_.num_parallel_batches_;
}
inline uint32_t InputReader::num_parallel_batches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_parallel_batches)
  return _internal_num_parallel_batches();
}
inline void InputReader::_internal_set_num_parallel_batches(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.num_parallel_batches_ = value;
}
inline void InputReader::set_num_parallel_batches(uint32_t value) {
  _internal_set_num_parallel_batches(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_parallel_batches)
}

// optional int32 num_prefetch_batches = 20 [default = 2];
inline bool InputReader::_internal_has_num_prefetch_batches() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool InputReader::has_num_prefetch_batches() const {
  return _internal_has_num_prefetch_batches();
}
inline void InputReader::clear_num_prefetch_batches() {
  _impl_.num_prefetch_batches_ = 2;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t InputReader::_internal_num_prefetch_batches() const {
  return _impl_.num_prefetch_batches_;
}
inline int32_t InputReader::num_prefetch_batches() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_prefetch_batches)
  return _internal_num_prefetch_batches();
}
inline void InputReader::_internal_set_num_prefetch_batches(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.num_prefetch_batches_ = value;
}
inline void InputReader::set_num_prefetch_batches(int32_t value) {
  _internal_set_num_prefetch_batches(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_prefetch_batches)
}

// optional uint32 queue_capacity = 3 [default = 2000, deprecated = true];
inline bool InputReader::_internal_has_queue_capacity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool InputReader::has_queue_capacity() const {
  return _internal_has_queue_capacity();
}
inline void InputReader::clear_queue_capacity() {
  _impl_.queue_capacity_ = 2000u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t InputReader::_internal_queue_capacity() const {
  return _impl_.queue_capacity_;
}
inline uint32_t InputReader::queue_capacity() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.queue_capacity)
  return _internal_queue_capacity();
}
inline void InputReader::_internal_set_queue_capacity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.queue_capacity_ = value;
}
inline void InputReader::set_queue_capacity(uint32_t value) {
  _internal_set_queue_capacity(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.queue_capacity)
}

// optional uint32 min_after_dequeue = 4 [default = 1000, deprecated = true];
inline bool InputReader::_internal_has_min_after_dequeue() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool InputReader::has_min_after_dequeue() const {
  return _internal_has_min_after_dequeue();
}
inline void InputReader::clear_min_after_dequeue() {
  _impl_.min_after_dequeue_ = 1000u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t InputReader::_internal_min_after_dequeue() const {
  return _impl_.min_after_dequeue_;
}
inline uint32_t InputReader::min_after_dequeue() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.min_after_dequeue)
  return _internal_min_after_dequeue();
}
inline void InputReader::_internal_set_min_after_dequeue(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.min_after_dequeue_ = value;
}
inline void InputReader::set_min_after_dequeue(uint32_t value) {
  _internal_set_min_after_dequeue(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.min_after_dequeue)
}

// optional uint32 read_block_length = 15 [default = 32];
inline bool InputReader::_internal_has_read_block_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool InputReader::has_read_block_length() const {
  return _internal_has_read_block_length();
}
inline void InputReader::clear_read_block_length() {
  _impl_.read_block_length_ = 32u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t InputReader::_internal_read_block_length() const {
  return _impl_.read_block_length_;
}
inline uint32_t InputReader::read_block_length() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.read_block_length)
  return _internal_read_block_length();
}
inline void InputReader::_internal_set_read_block_length(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.read_block_length_ = value;
}
inline void InputReader::set_read_block_length(uint32_t value) {
  _internal_set_read_block_length(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.read_block_length)
}

// optional uint32 prefetch_size = 13 [default = 512, deprecated = true];
inline bool InputReader::_internal_has_prefetch_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool InputReader::has_prefetch_size() const {
  return _internal_has_prefetch_size();
}
inline void InputReader::clear_prefetch_size() {
  _impl_.prefetch_size_ = 512u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t InputReader::_internal_prefetch_size() const {
  return _impl_.prefetch_size_;
}
inline uint32_t InputReader::prefetch_size() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.prefetch_size)
  return _internal_prefetch_size();
}
inline void InputReader::_internal_set_prefetch_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.prefetch_size_ = value;
}
inline void InputReader::set_prefetch_size(uint32_t value) {
  _internal_set_prefetch_size(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.prefetch_size)
}

// optional uint32 num_parallel_map_calls = 14 [default = 64, deprecated = true];
inline bool InputReader::_internal_has_num_parallel_map_calls() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool InputReader::has_num_parallel_map_calls() const {
  return _internal_has_num_parallel_map_calls();
}
inline void InputReader::clear_num_parallel_map_calls() {
  _impl_.num_parallel_map_calls_ = 64u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t InputReader::_internal_num_parallel_map_calls() const {
  return _impl_.num_parallel_map_calls_;
}
inline uint32_t InputReader::num_parallel_map_calls() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_parallel_map_calls)
  return _internal_num_parallel_map_calls();
}
inline void InputReader::_internal_set_num_parallel_map_calls(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.num_parallel_map_calls_ = value;
}
inline void InputReader::set_num_parallel_map_calls(uint32_t value) {
  _internal_set_num_parallel_map_calls(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_parallel_map_calls)
}

// optional int32 num_additional_channels = 18 [default = 0];
inline bool InputReader::_internal_has_num_additional_channels() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool InputReader::has_num_additional_channels() const {
  return _internal_has_num_additional_channels();
}
inline void InputReader::clear_num_additional_channels() {
  _impl_.num_additional_channels_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t InputReader::_internal_num_additional_channels() const {
  return _impl_.num_additional_channels_;
}
inline int32_t InputReader::num_additional_channels() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_additional_channels)
  return _internal_num_additional_channels();
}
inline void InputReader::_internal_set_num_additional_channels(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.num_additional_channels_ = value;
}
inline void InputReader::set_num_additional_channels(int32_t value) {
  _internal_set_num_additional_channels(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_additional_channels)
}

// optional uint32 num_keypoints = 16 [default = 0];
inline bool InputReader::_internal_has_num_keypoints() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool InputReader::has_num_keypoints() const {
  return _internal_has_num_keypoints();
}
inline void InputReader::clear_num_keypoints() {
  _impl_.num_keypoints_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t InputReader::_internal_num_keypoints() const {
  return _impl_.num_keypoints_;
}
inline uint32_t InputReader::num_keypoints() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.num_keypoints)
  return _internal_num_keypoints();
}
inline void InputReader::_internal_set_num_keypoints(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.num_keypoints_ = value;
}
inline void InputReader::set_num_keypoints(uint32_t value) {
  _internal_set_num_keypoints(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.num_keypoints)
}

// optional int32 max_number_of_boxes = 21 [default = 100];
inline bool InputReader::_internal_has_max_number_of_boxes() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool InputReader::has_max_number_of_boxes() const {
  return _internal_has_max_number_of_boxes();
}
inline void InputReader::clear_max_number_of_boxes() {
  _impl_.max_number_of_boxes_ = 100;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t InputReader::_internal_max_number_of_boxes() const {
  return _impl_.max_number_of_boxes_;
}
inline int32_t InputReader::max_number_of_boxes() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.max_number_of_boxes)
  return _internal_max_number_of_boxes();
}
inline void InputReader::_internal_set_max_number_of_boxes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.max_number_of_boxes_ = value;
}
inline void InputReader::set_max_number_of_boxes(int32_t value) {
  _internal_set_max_number_of_boxes(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.max_number_of_boxes)
}

// optional bool load_multiclass_scores = 24 [default = false];
inline bool InputReader::_internal_has_load_multiclass_scores() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool InputReader::has_load_multiclass_scores() const {
  return _internal_has_load_multiclass_scores();
}
inline void InputReader::clear_load_multiclass_scores() {
  _impl_.load_multiclass_scores_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool InputReader::_internal_load_multiclass_scores() const {
  return _impl_.load_multiclass_scores_;
}
inline bool InputReader::load_multiclass_scores() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.load_multiclass_scores)
  return _internal_load_multiclass_scores();
}
inline void InputReader::_internal_set_load_multiclass_scores(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.load_multiclass_scores_ = value;
}
inline void InputReader::set_load_multiclass_scores(bool value) {
  _internal_set_load_multiclass_scores(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.load_multiclass_scores)
}

// optional bool load_instance_masks = 7 [default = false];
inline bool InputReader::_internal_has_load_instance_masks() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool InputReader::has_load_instance_masks() const {
  return _internal_has_load_instance_masks();
}
inline void InputReader::clear_load_instance_masks() {
  _impl_.load_instance_masks_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool InputReader::_internal_load_instance_masks() const {
  return _impl_.load_instance_masks_;
}
inline bool InputReader::load_instance_masks() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.load_instance_masks)
  return _internal_load_instance_masks();
}
inline void InputReader::_internal_set_load_instance_masks(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.load_instance_masks_ = value;
}
inline void InputReader::set_load_instance_masks(bool value) {
  _internal_set_load_instance_masks(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.load_instance_masks)
}

// optional .object_detection.protos.InstanceMaskType mask_type = 10 [default = NUMERICAL_MASKS];
inline bool InputReader::_internal_has_mask_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool InputReader::has_mask_type() const {
  return _internal_has_mask_type();
}
inline void InputReader::clear_mask_type() {
  _impl_.mask_type_ = 1;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::object_detection::protos::InstanceMaskType InputReader::_internal_mask_type() const {
  return static_cast< ::object_detection::protos::InstanceMaskType >(_impl_.mask_type_);
}
inline ::object_detection::protos::InstanceMaskType InputReader::mask_type() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.mask_type)
  return _internal_mask_type();
}
inline void InputReader::_internal_set_mask_type(::object_detection::protos::InstanceMaskType value) {
  assert(::object_detection::protos::InstanceMaskType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.mask_type_ = value;
}
inline void InputReader::set_mask_type(::object_detection::protos::InstanceMaskType value) {
  _internal_set_mask_type(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.mask_type)
}

// optional bool use_display_name = 17 [default = false];
inline bool InputReader::_internal_has_use_display_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool InputReader::has_use_display_name() const {
  return _internal_has_use_display_name();
}
inline void InputReader::clear_use_display_name() {
  _impl_.use_display_name_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool InputReader::_internal_use_display_name() const {
  return _impl_.use_display_name_;
}
inline bool InputReader::use_display_name() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.use_display_name)
  return _internal_use_display_name();
}
inline void InputReader::_internal_set_use_display_name(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.use_display_name_ = value;
}
inline void InputReader::set_use_display_name(bool value) {
  _internal_set_use_display_name(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.InputReader.use_display_name)
}

// .object_detection.protos.TFRecordInputReader tf_record_input_reader = 8;
inline bool InputReader::_internal_has_tf_record_input_reader() const {
  return input_reader_case() == kTfRecordInputReader;
}
inline bool InputReader::has_tf_record_input_reader() const {
  return _internal_has_tf_record_input_reader();
}
inline void InputReader::set_has_tf_record_input_reader() {
  _impl_._oneof_case_[0] = kTfRecordInputReader;
}
inline void InputReader::clear_tf_record_input_reader() {
  if (_internal_has_tf_record_input_reader()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.input_reader_.tf_record_input_reader_;
    }
    clear_has_input_reader();
  }
}
inline ::object_detection::protos::TFRecordInputReader* InputReader::release_tf_record_input_reader() {
  // @@protoc_insertion_point(field_release:object_detection.protos.InputReader.tf_record_input_reader)
  if (_internal_has_tf_record_input_reader()) {
    clear_has_input_reader();
    ::object_detection::protos::TFRecordInputReader* temp = _impl_.input_reader_.tf_record_input_reader_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.input_reader_.tf_record_input_reader_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::TFRecordInputReader& InputReader::_internal_tf_record_input_reader() const {
  return _internal_has_tf_record_input_reader()
      ? *_impl_.input_reader_.tf_record_input_reader_
      : reinterpret_cast< ::object_detection::protos::TFRecordInputReader&>(::object_detection::protos::_TFRecordInputReader_default_instance_);
}
inline const ::object_detection::protos::TFRecordInputReader& InputReader::tf_record_input_reader() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.tf_record_input_reader)
  return _internal_tf_record_input_reader();
}
inline ::object_detection::protos::TFRecordInputReader* InputReader::unsafe_arena_release_tf_record_input_reader() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.InputReader.tf_record_input_reader)
  if (_internal_has_tf_record_input_reader()) {
    clear_has_input_reader();
    ::object_detection::protos::TFRecordInputReader* temp = _impl_.input_reader_.tf_record_input_reader_;
    _impl_.input_reader_.tf_record_input_reader_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void InputReader::unsafe_arena_set_allocated_tf_record_input_reader(::object_detection::protos::TFRecordInputReader* tf_record_input_reader) {
  clear_input_reader();
  if (tf_record_input_reader) {
    set_has_tf_record_input_reader();
    _impl_.input_reader_.tf_record_input_reader_ = tf_record_input_reader;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.InputReader.tf_record_input_reader)
}
inline ::object_detection::protos::TFRecordInputReader* InputReader::_internal_mutable_tf_record_input_reader() {
  if (!_internal_has_tf_record_input_reader()) {
    clear_input_reader();
    set_has_tf_record_input_reader();
    _impl_.input_reader_.tf_record_input_reader_ = CreateMaybeMessage< ::object_detection::protos::TFRecordInputReader >(GetArenaForAllocation());
  }
  return _impl_.input_reader_.tf_record_input_reader_;
}
inline ::object_detection::protos::TFRecordInputReader* InputReader::mutable_tf_record_input_reader() {
  ::object_detection::protos::TFRecordInputReader* _msg = _internal_mutable_tf_record_input_reader();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.InputReader.tf_record_input_reader)
  return _msg;
}

// .object_detection.protos.ExternalInputReader external_input_reader = 9;
inline bool InputReader::_internal_has_external_input_reader() const {
  return input_reader_case() == kExternalInputReader;
}
inline bool InputReader::has_external_input_reader() const {
  return _internal_has_external_input_reader();
}
inline void InputReader::set_has_external_input_reader() {
  _impl_._oneof_case_[0] = kExternalInputReader;
}
inline void InputReader::clear_external_input_reader() {
  if (_internal_has_external_input_reader()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.input_reader_.external_input_reader_;
    }
    clear_has_input_reader();
  }
}
inline ::object_detection::protos::ExternalInputReader* InputReader::release_external_input_reader() {
  // @@protoc_insertion_point(field_release:object_detection.protos.InputReader.external_input_reader)
  if (_internal_has_external_input_reader()) {
    clear_has_input_reader();
    ::object_detection::protos::ExternalInputReader* temp = _impl_.input_reader_.external_input_reader_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.input_reader_.external_input_reader_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::object_detection::protos::ExternalInputReader& InputReader::_internal_external_input_reader() const {
  return _internal_has_external_input_reader()
      ? *_impl_.input_reader_.external_input_reader_
      : reinterpret_cast< ::object_detection::protos::ExternalInputReader&>(::object_detection::protos::_ExternalInputReader_default_instance_);
}
inline const ::object_detection::protos::ExternalInputReader& InputReader::external_input_reader() const {
  // @@protoc_insertion_point(field_get:object_detection.protos.InputReader.external_input_reader)
  return _internal_external_input_reader();
}
inline ::object_detection::protos::ExternalInputReader* InputReader::unsafe_arena_release_external_input_reader() {
  // @@protoc_insertion_point(field_unsafe_arena_release:object_detection.protos.InputReader.external_input_reader)
  if (_internal_has_external_input_reader()) {
    clear_has_input_reader();
    ::object_detection::protos::ExternalInputReader* temp = _impl_.input_reader_.external_input_reader_;
    _impl_.input_reader_.external_input_reader_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void InputReader::unsafe_arena_set_allocated_external_input_reader(::object_detection::protos::ExternalInputReader* external_input_reader) {
  clear_input_reader();
  if (external_input_reader) {
    set_has_external_input_reader();
    _impl_.input_reader_.external_input_reader_ = external_input_reader;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:object_detection.protos.InputReader.external_input_reader)
}
inline ::object_detection::protos::ExternalInputReader* InputReader::_internal_mutable_external_input_reader() {
  if (!_internal_has_external_input_reader()) {
    clear_input_reader();
    set_has_external_input_reader();
    _impl_.input_reader_.external_input_reader_ = CreateMaybeMessage< ::object_detection::protos::ExternalInputReader >(GetArenaForAllocation());
  }
  return _impl_.input_reader_.external_input_reader_;
}
inline ::object_detection::protos::ExternalInputReader* InputReader::mutable_external_input_reader() {
  ::object_detection::protos::ExternalInputReader* _msg = _internal_mutable_external_input_reader();
  // @@protoc_insertion_point(field_mutable:object_detection.protos.InputReader.external_input_reader)
  return _msg;
}

inline bool InputReader::has_input_reader() const {
  return input_reader_case() != INPUT_READER_NOT_SET;
}
inline void InputReader::clear_has_input_reader() {
  _impl_._oneof_case_[0] = INPUT_READER_NOT_SET;
}
inline InputReader::InputReaderCase InputReader::input_reader_case() const {
  return InputReader::InputReaderCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// TFRecordInputReader

// repeated string input_path = 1;
inline int TFRecordInputReader::_internal_input_path_size() const {
  return _impl_.input_path_.size();
}
inline int TFRecordInputReader::input_path_size() const {
  return _internal_input_path_size();
}
inline void TFRecordInputReader::clear_input_path() {
  _impl_.input_path_.Clear();
}
inline std::string* TFRecordInputReader::add_input_path() {
  std::string* _s = _internal_add_input_path();
  // @@protoc_insertion_point(field_add_mutable:object_detection.protos.TFRecordInputReader.input_path)
  return _s;
}
inline const std::string& TFRecordInputReader::_internal_input_path(int index) const {
  return _impl_.input_path_.Get(index);
}
inline const std::string& TFRecordInputReader::input_path(int index) const {
  // @@protoc_insertion_point(field_get:object_detection.protos.TFRecordInputReader.input_path)
  return _internal_input_path(index);
}
inline std::string* TFRecordInputReader::mutable_input_path(int index) {
  // @@protoc_insertion_point(field_mutable:object_detection.protos.TFRecordInputReader.input_path)
  return _impl_.input_path_.Mutable(index);
}
inline void TFRecordInputReader::set_input_path(int index, const std::string& value) {
  _impl_.input_path_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::set_input_path(int index, std::string&& value) {
  _impl_.input_path_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::set_input_path(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.input_path_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::set_input_path(int index, const char* value, size_t size) {
  _impl_.input_path_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:object_detection.protos.TFRecordInputReader.input_path)
}
inline std::string* TFRecordInputReader::_internal_add_input_path() {
  return _impl_.input_path_.Add();
}
inline void TFRecordInputReader::add_input_path(const std::string& value) {
  _impl_.input_path_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::add_input_path(std::string&& value) {
  _impl_.input_path_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::add_input_path(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.input_path_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:object_detection.protos.TFRecordInputReader.input_path)
}
inline void TFRecordInputReader::add_input_path(const char* value, size_t size) {
  _impl_.input_path_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:object_detection.protos.TFRecordInputReader.input_path)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TFRecordInputReader::input_path() const {
  // @@protoc_insertion_point(field_list:object_detection.protos.TFRecordInputReader.input_path)
  return _impl_.input_path_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TFRecordInputReader::mutable_input_path() {
  // @@protoc_insertion_point(field_mutable_list:object_detection.protos.TFRecordInputReader.input_path)
  return &_impl_.input_path_;
}

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

// ExternalInputReader

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace object_detection

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::object_detection::protos::InstanceMaskType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::object_detection::protos::InstanceMaskType>() {
  return ::object_detection::protos::InstanceMaskType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_object_5fdetection_2fprotos_2finput_5freader_2eproto
