// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: lib/config/drive.proto
// Protobuf C++ Version: 7.36.0

#ifndef lib_2fconfig_2fdrive_2eproto_2epb_2eh
#define lib_2fconfig_2fdrive_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7036000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.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/message_lite.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"
#include "lib/config/common.pb.h"
#include "lib/external/fl2.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_lib_2fconfig_2fdrive_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2fconfig_2fdrive_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2fconfig_2fdrive_2eproto;
}  // extern "C"
enum DriveProto_ErrorBehaviour : int;
extern const uint32_t DriveProto_ErrorBehaviour_internal_data_[];
class DriveProto;
struct DriveProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DriveProtoGlobalsTypeInternal DriveProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull DriveProto_class_data_;
#else
extern const DriveProtoGlobalsTypeInternal DriveProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::DriveProto_ErrorBehaviour_internal_data_>
    internal::EnumTraitsImpl::value<::DriveProto_ErrorBehaviour>;
}  // namespace protobuf
}  // namespace google

enum DriveProto_ErrorBehaviour : int {
  DriveProto_ErrorBehaviour_NOTHING = 0,
  DriveProto_ErrorBehaviour_JIGGLE = 1,
  DriveProto_ErrorBehaviour_RECALIBRATE = 2,
};

extern const uint32_t DriveProto_ErrorBehaviour_internal_data_[];
inline constexpr DriveProto_ErrorBehaviour DriveProto_ErrorBehaviour_ErrorBehaviour_MIN =
    static_cast<DriveProto_ErrorBehaviour>(0);
inline constexpr DriveProto_ErrorBehaviour DriveProto_ErrorBehaviour_ErrorBehaviour_MAX =
    static_cast<DriveProto_ErrorBehaviour>(2);
[[nodiscard]] inline bool DriveProto_ErrorBehaviour_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int DriveProto_ErrorBehaviour_ErrorBehaviour_ARRAYSIZE = 2 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
DriveProto_ErrorBehaviour_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(DriveProto_ErrorBehaviour) {
  return DriveProto_ErrorBehaviour_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& DriveProto_ErrorBehaviour_Name(T value) {
  static_assert(::std::is_same<T, DriveProto_ErrorBehaviour>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ErrorBehaviour_Name().");
  return DriveProto_ErrorBehaviour_Name(static_cast<DriveProto_ErrorBehaviour>(value));
}
template <>
[[nodiscard]] inline const ::std::string& DriveProto_ErrorBehaviour_Name(DriveProto_ErrorBehaviour value) {
  return ::google::protobuf::internal::NameOfDenseEnum<DriveProto_ErrorBehaviour_descriptor, 0, 2>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool DriveProto_ErrorBehaviour_Parse(
    ::absl::string_view name, DriveProto_ErrorBehaviour* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<DriveProto_ErrorBehaviour>(DriveProto_ErrorBehaviour_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DriveProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:DriveProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DriveProto() : DriveProto(nullptr) {}
  ~DriveProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DriveProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DriveProto));
  }
#endif

  template <typename = void>
  explicit constexpr DriveProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DriveProto(const DriveProto& from) : DriveProto(nullptr, from) {}
  inline DriveProto(DriveProto&& from) noexcept : DriveProto(nullptr, ::std::move(from)) {}
  inline DriveProto& operator=(const DriveProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DriveProto& operator=(DriveProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DriveProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DriveProto>(&DriveProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(DriveProto& a, DriveProto& b) { a.Swap(&b); }
  inline void Swap(DriveProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DriveProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] DriveProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DriveProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DriveProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const DriveProto& from) { DriveProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DriveProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "DriveProto"; }

  explicit DriveProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DriveProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DriveProto& from);
  DriveProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DriveProto&& from) noexcept
      : DriveProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using ErrorBehaviour = DriveProto_ErrorBehaviour;
  static constexpr ErrorBehaviour NOTHING = DriveProto_ErrorBehaviour_NOTHING;
  static constexpr ErrorBehaviour JIGGLE = DriveProto_ErrorBehaviour_JIGGLE;
  static constexpr ErrorBehaviour RECALIBRATE = DriveProto_ErrorBehaviour_RECALIBRATE;
  [[nodiscard]] static inline bool ErrorBehaviour_IsValid(int value) {
    return DriveProto_ErrorBehaviour_IsValid(value);
  }
  static constexpr ErrorBehaviour ErrorBehaviour_MIN = DriveProto_ErrorBehaviour_ErrorBehaviour_MIN;
  static constexpr ErrorBehaviour ErrorBehaviour_MAX = DriveProto_ErrorBehaviour_ErrorBehaviour_MAX;
  static constexpr int ErrorBehaviour_ARRAYSIZE = DriveProto_ErrorBehaviour_ErrorBehaviour_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ErrorBehaviour_descriptor() {
    return DriveProto_ErrorBehaviour_descriptor();
  }
  template <typename T>
  [[nodiscard]] static inline const ::std::string& ErrorBehaviour_Name(T value) {
    return DriveProto_ErrorBehaviour_Name(value);
  }
  [[nodiscard]] static inline bool ErrorBehaviour_Parse(
      ::absl::string_view name, ErrorBehaviour* PROTOBUF_NONNULL value) {
    return DriveProto_ErrorBehaviour_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kTracksFieldNumber = 8,
    kDriveFieldNumber = 1,
    kIndexModeFieldNumber = 2,
    kHardSectorThresholdNsFieldNumber = 4,
    kHardSectorCountFieldNumber = 3,
    kHighDensityFieldNumber = 5,
    kSyncWithIndexFieldNumber = 6,
    kHeadBiasFieldNumber = 9,
    kGroupOffsetFieldNumber = 10,
    kRotationalPeriodMsFieldNumber = 12,
    kDriveTypeFieldNumber = 11,
    kErrorBehaviourFieldNumber = 13,
    kRevolutionsFieldNumber = 7,
  };
  // optional string tracks = 8 [default = "c0-80h0-1", json_name = "tracks", (.help) = "Tracks supported by drive"];
  [[nodiscard]] bool has_tracks() const;
  void clear_tracks() ;
  [[nodiscard]] const ::std::string& tracks() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_tracks(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_tracks();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_tracks();
  void set_allocated_tracks(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_tracks() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_tracks(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_tracks();

  public:
  // optional int32 drive = 1 [default = 0, json_name = "drive", (.help) = "which drive to write to (0 or 1)"];
  [[nodiscard]] bool has_drive() const;
  void clear_drive() ;
  [[nodiscard]] ::int32_t drive() const;
  void set_drive(::int32_t value);

  private:
  ::int32_t _internal_drive() const;
  void _internal_set_drive(::int32_t value);

  public:
  // optional .IndexMode index_mode = 2 [default = INDEXMODE_DRIVE, json_name = "indexMode", (.help) = "index pulse source"];
  [[nodiscard]] bool has_index_mode() const;
  void clear_index_mode() ;
  [[nodiscard]] ::IndexMode index_mode() const;
  void set_index_mode(::IndexMode value);

  private:
  ::IndexMode _internal_index_mode() const;
  void _internal_set_index_mode(::IndexMode value);

  public:
  // optional double hard_sector_threshold_ns = 4 [default = 0, json_name = "hardSectorThresholdNs", (.help) = "index pulses longer than this interval are considered sector markers; shorter indicates an true index marker"];
  [[nodiscard]] bool has_hard_sector_threshold_ns() const;
  void clear_hard_sector_threshold_ns() ;
  [[nodiscard]] double hard_sector_threshold_ns() const;
  void set_hard_sector_threshold_ns(double value);

  private:
  double _internal_hard_sector_threshold_ns() const;
  void _internal_set_hard_sector_threshold_ns(double value);

  public:
  // optional int32 hard_sector_count = 3 [default = 0, json_name = "hardSectorCount", (.help) = "number of hard sectors on disk"];
  [[nodiscard]] bool has_hard_sector_count() const;
  void clear_hard_sector_count() ;
  [[nodiscard]] ::int32_t hard_sector_count() const;
  void set_hard_sector_count(::int32_t value);

  private:
  ::int32_t _internal_hard_sector_count() const;
  void _internal_set_hard_sector_count(::int32_t value);

  public:
  // optional bool high_density = 5 [default = false, json_name = "highDensity", (.help) = "set if this is a high density disk"];
  [[nodiscard]] bool has_high_density() const;
  void clear_high_density() ;
  [[nodiscard]] bool high_density() const;
  void set_high_density(bool value);

  private:
  bool _internal_high_density() const;
  void _internal_set_high_density(bool value);

  public:
  // optional bool sync_with_index = 6 [default = false, json_name = "syncWithIndex", (.help) = "start reading at index mark"];
  [[nodiscard]] bool has_sync_with_index() const;
  void clear_sync_with_index() ;
  [[nodiscard]] bool sync_with_index() const;
  void set_sync_with_index(bool value);

  private:
  bool _internal_sync_with_index() const;
  void _internal_set_sync_with_index(bool value);

  public:
  // optional int32 head_bias = 9 [default = 0, json_name = "headBias", (.help) = "Bias to apply to the head position (in tracks)"];
  [[nodiscard]] bool has_head_bias() const;
  void clear_head_bias() ;
  [[nodiscard]] ::int32_t head_bias() const;
  void set_head_bias(::int32_t value);

  private:
  ::int32_t _internal_head_bias() const;
  void _internal_set_head_bias(::int32_t value);

  public:
  // optional int32 group_offset = 10 [default = 0, json_name = "groupOffset", (.help) = "When writing groups, erase all tracks except this one in each group"];
  [[nodiscard]] bool has_group_offset() const;
  void clear_group_offset() ;
  [[nodiscard]] ::int32_t group_offset() const;
  void set_group_offset(::int32_t value);

  private:
  ::int32_t _internal_group_offset() const;
  void _internal_set_group_offset(::int32_t value);

  public:
  // optional double rotational_period_ms = 12 [default = 0, json_name = "rotationalPeriodMs", (.help) = "Rotational period of the drive in milliseconds (0 to autodetect)"];
  [[nodiscard]] bool has_rotational_period_ms() const;
  void clear_rotational_period_ms() ;
  [[nodiscard]] double rotational_period_ms() const;
  void set_rotational_period_ms(double value);

  private:
  double _internal_rotational_period_ms() const;
  void _internal_set_rotational_period_ms(double value);

  public:
  // optional .DriveType drive_type = 11 [default = DRIVETYPE_UNKNOWN, json_name = "driveType", (.help) = "Type of drive"];
  [[nodiscard]] bool has_drive_type() const;
  void clear_drive_type() ;
  [[nodiscard]] ::DriveType drive_type() const;
  void set_drive_type(::DriveType value);

  private:
  ::DriveType _internal_drive_type() const;
  void _internal_set_drive_type(::DriveType value);

  public:
  // optional .DriveProto.ErrorBehaviour error_behaviour = 13 [default = JIGGLE, json_name = "errorBehaviour", (.help) = "what to do when an error occurs during reads"];
  [[nodiscard]] bool has_error_behaviour() const;
  void clear_error_behaviour() ;
  [[nodiscard]] ::DriveProto_ErrorBehaviour error_behaviour() const;
  void set_error_behaviour(::DriveProto_ErrorBehaviour value);

  private:
  ::DriveProto_ErrorBehaviour _internal_error_behaviour() const;
  void _internal_set_error_behaviour(::DriveProto_ErrorBehaviour value);

  public:
  // optional double revolutions = 7 [default = 2.5, json_name = "revolutions", (.help) = "number of revolutions to read"];
  [[nodiscard]] bool has_revolutions() const;
  void clear_revolutions() ;
  [[nodiscard]] double revolutions() const;
  void set_revolutions(double value);

  private:
  double _internal_revolutions() const;
  void _internal_set_revolutions(double value);

  public:
  // @@protoc_insertion_point(class_scope:DriveProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 13,
                          3, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DriveProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_tracks_;
    ::google::protobuf::internal::ArenaStringPtr tracks_;
    ::int32_t drive_;
    int index_mode_;
    double hard_sector_threshold_ns_;
    ::int32_t hard_sector_count_;
    bool high_density_;
    bool sync_with_index_;
    ::int32_t head_bias_;
    ::int32_t group_offset_;
    double rotational_period_ms_;
    int drive_type_;
    int error_behaviour_;
    double revolutions_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2fconfig_2fdrive_2eproto;
};

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




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


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

// DriveProto

// optional int32 drive = 1 [default = 0, json_name = "drive", (.help) = "which drive to write to (0 or 1)"];
inline bool DriveProto::has_drive() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void DriveProto::clear_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drive_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::int32_t DriveProto::drive() const {
  // @@protoc_insertion_point(field_get:DriveProto.drive)
  return _internal_drive();
}
inline void DriveProto::set_drive(::int32_t value) {
  _internal_set_drive(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:DriveProto.drive)
}
inline ::int32_t DriveProto::_internal_drive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.drive_;
}
inline void DriveProto::_internal_set_drive(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drive_ = value;
}

// optional .IndexMode index_mode = 2 [default = INDEXMODE_DRIVE, json_name = "indexMode", (.help) = "index pulse source"];
inline bool DriveProto::has_index_mode() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void DriveProto::clear_index_mode() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.index_mode_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::IndexMode DriveProto::index_mode() const {
  // @@protoc_insertion_point(field_get:DriveProto.index_mode)
  return _internal_index_mode();
}
inline void DriveProto::set_index_mode(::IndexMode value) {
  _internal_set_index_mode(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:DriveProto.index_mode)
}
inline ::IndexMode DriveProto::_internal_index_mode() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::IndexMode>(_impl_.index_mode_);
}
inline void DriveProto::_internal_set_index_mode(::IndexMode value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::IndexMode_internal_data_));
                                          _impl_.index_mode_ = value;
}

// optional int32 hard_sector_count = 3 [default = 0, json_name = "hardSectorCount", (.help) = "number of hard sectors on disk"];
inline bool DriveProto::has_hard_sector_count() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void DriveProto::clear_hard_sector_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_sector_count_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::int32_t DriveProto::hard_sector_count() const {
  // @@protoc_insertion_point(field_get:DriveProto.hard_sector_count)
  return _internal_hard_sector_count();
}
inline void DriveProto::set_hard_sector_count(::int32_t value) {
  _internal_set_hard_sector_count(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:DriveProto.hard_sector_count)
}
inline ::int32_t DriveProto::_internal_hard_sector_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hard_sector_count_;
}
inline void DriveProto::_internal_set_hard_sector_count(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_sector_count_ = value;
}

// optional double hard_sector_threshold_ns = 4 [default = 0, json_name = "hardSectorThresholdNs", (.help) = "index pulses longer than this interval are considered sector markers; shorter indicates an true index marker"];
inline bool DriveProto::has_hard_sector_threshold_ns() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void DriveProto::clear_hard_sector_threshold_ns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_sector_threshold_ns_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline double DriveProto::hard_sector_threshold_ns() const {
  // @@protoc_insertion_point(field_get:DriveProto.hard_sector_threshold_ns)
  return _internal_hard_sector_threshold_ns();
}
inline void DriveProto::set_hard_sector_threshold_ns(double value) {
  _internal_set_hard_sector_threshold_ns(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:DriveProto.hard_sector_threshold_ns)
}
inline double DriveProto::_internal_hard_sector_threshold_ns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hard_sector_threshold_ns_;
}
inline void DriveProto::_internal_set_hard_sector_threshold_ns(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_sector_threshold_ns_ = value;
}

// optional bool high_density = 5 [default = false, json_name = "highDensity", (.help) = "set if this is a high density disk"];
inline bool DriveProto::has_high_density() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void DriveProto::clear_high_density() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.high_density_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline bool DriveProto::high_density() const {
  // @@protoc_insertion_point(field_get:DriveProto.high_density)
  return _internal_high_density();
}
inline void DriveProto::set_high_density(bool value) {
  _internal_set_high_density(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:DriveProto.high_density)
}
inline bool DriveProto::_internal_high_density() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.high_density_;
}
inline void DriveProto::_internal_set_high_density(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.high_density_ = value;
}

// optional bool sync_with_index = 6 [default = false, json_name = "syncWithIndex", (.help) = "start reading at index mark"];
inline bool DriveProto::has_sync_with_index() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void DriveProto::clear_sync_with_index() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sync_with_index_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline bool DriveProto::sync_with_index() const {
  // @@protoc_insertion_point(field_get:DriveProto.sync_with_index)
  return _internal_sync_with_index();
}
inline void DriveProto::set_sync_with_index(bool value) {
  _internal_set_sync_with_index(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:DriveProto.sync_with_index)
}
inline bool DriveProto::_internal_sync_with_index() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sync_with_index_;
}
inline void DriveProto::_internal_set_sync_with_index(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sync_with_index_ = value;
}

// optional double revolutions = 7 [default = 2.5, json_name = "revolutions", (.help) = "number of revolutions to read"];
inline bool DriveProto::has_revolutions() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void DriveProto::clear_revolutions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.revolutions_ = 2.5;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline double DriveProto::revolutions() const {
  // @@protoc_insertion_point(field_get:DriveProto.revolutions)
  return _internal_revolutions();
}
inline void DriveProto::set_revolutions(double value) {
  _internal_set_revolutions(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:DriveProto.revolutions)
}
inline double DriveProto::_internal_revolutions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.revolutions_;
}
inline void DriveProto::_internal_set_revolutions(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.revolutions_ = value;
}

// optional string tracks = 8 [default = "c0-80h0-1", json_name = "tracks", (.help) = "Tracks supported by drive"];
inline bool DriveProto::has_tracks() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void DriveProto::clear_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tracks_.ClearToDefault(::DriveProto::Impl_::_i_give_permission_to_break_this_code_default_tracks_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& DriveProto::tracks() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:DriveProto.tracks)
  if (_impl_.tracks_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_tracks_.get();
  }
  return _internal_tracks();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DriveProto::set_tracks(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.tracks_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:DriveProto.tracks)
}
inline ::std::string* PROTOBUF_NONNULL DriveProto::mutable_tracks()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_tracks();
  // @@protoc_insertion_point(field_mutable:DriveProto.tracks)
  return _s;
}
inline const ::std::string& DriveProto::_internal_tracks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.tracks_.Get();
}
inline void DriveProto::_internal_set_tracks(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.tracks_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DriveProto::_internal_mutable_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.tracks_.Mutable(::DriveProto::Impl_::_i_give_permission_to_break_this_code_default_tracks_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DriveProto::release_tracks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:DriveProto.tracks)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.tracks_.Release();
}
inline void DriveProto::set_allocated_tracks(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.tracks_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:DriveProto.tracks)
}

// optional int32 head_bias = 9 [default = 0, json_name = "headBias", (.help) = "Bias to apply to the head position (in tracks)"];
inline bool DriveProto::has_head_bias() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void DriveProto::clear_head_bias() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_bias_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline ::int32_t DriveProto::head_bias() const {
  // @@protoc_insertion_point(field_get:DriveProto.head_bias)
  return _internal_head_bias();
}
inline void DriveProto::set_head_bias(::int32_t value) {
  _internal_set_head_bias(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:DriveProto.head_bias)
}
inline ::int32_t DriveProto::_internal_head_bias() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.head_bias_;
}
inline void DriveProto::_internal_set_head_bias(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.head_bias_ = value;
}

// optional int32 group_offset = 10 [default = 0, json_name = "groupOffset", (.help) = "When writing groups, erase all tracks except this one in each group"];
inline bool DriveProto::has_group_offset() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void DriveProto::clear_group_offset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.group_offset_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline ::int32_t DriveProto::group_offset() const {
  // @@protoc_insertion_point(field_get:DriveProto.group_offset)
  return _internal_group_offset();
}
inline void DriveProto::set_group_offset(::int32_t value) {
  _internal_set_group_offset(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:DriveProto.group_offset)
}
inline ::int32_t DriveProto::_internal_group_offset() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.group_offset_;
}
inline void DriveProto::_internal_set_group_offset(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.group_offset_ = value;
}

// optional .DriveType drive_type = 11 [default = DRIVETYPE_UNKNOWN, json_name = "driveType", (.help) = "Type of drive"];
inline bool DriveProto::has_drive_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void DriveProto::clear_drive_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.drive_type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::DriveType DriveProto::drive_type() const {
  // @@protoc_insertion_point(field_get:DriveProto.drive_type)
  return _internal_drive_type();
}
inline void DriveProto::set_drive_type(::DriveType value) {
  _internal_set_drive_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:DriveProto.drive_type)
}
inline ::DriveType DriveProto::_internal_drive_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::DriveType>(_impl_.drive_type_);
}
inline void DriveProto::_internal_set_drive_type(::DriveType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::DriveType_internal_data_));
                                          _impl_.drive_type_ = value;
}

// optional double rotational_period_ms = 12 [default = 0, json_name = "rotationalPeriodMs", (.help) = "Rotational period of the drive in milliseconds (0 to autodetect)"];
inline bool DriveProto::has_rotational_period_ms() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void DriveProto::clear_rotational_period_ms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rotational_period_ms_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline double DriveProto::rotational_period_ms() const {
  // @@protoc_insertion_point(field_get:DriveProto.rotational_period_ms)
  return _internal_rotational_period_ms();
}
inline void DriveProto::set_rotational_period_ms(double value) {
  _internal_set_rotational_period_ms(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:DriveProto.rotational_period_ms)
}
inline double DriveProto::_internal_rotational_period_ms() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rotational_period_ms_;
}
inline void DriveProto::_internal_set_rotational_period_ms(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rotational_period_ms_ = value;
}

// optional .DriveProto.ErrorBehaviour error_behaviour = 13 [default = JIGGLE, json_name = "errorBehaviour", (.help) = "what to do when an error occurs during reads"];
inline bool DriveProto::has_error_behaviour() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void DriveProto::clear_error_behaviour() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.error_behaviour_ = 1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline ::DriveProto_ErrorBehaviour DriveProto::error_behaviour() const {
  // @@protoc_insertion_point(field_get:DriveProto.error_behaviour)
  return _internal_error_behaviour();
}
inline void DriveProto::set_error_behaviour(::DriveProto_ErrorBehaviour value) {
  _internal_set_error_behaviour(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:DriveProto.error_behaviour)
}
inline ::DriveProto_ErrorBehaviour DriveProto::_internal_error_behaviour() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::DriveProto_ErrorBehaviour>(_impl_.error_behaviour_);
}
inline void DriveProto::_internal_set_error_behaviour(::DriveProto_ErrorBehaviour value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::DriveProto_ErrorBehaviour_internal_data_));
                                          _impl_.error_behaviour_ = value;
}

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

// @@protoc_insertion_point(namespace_scope)


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::DriveProto_ErrorBehaviour> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::DriveProto_ErrorBehaviour>() {
  return ::DriveProto_ErrorBehaviour_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // lib_2fconfig_2fdrive_2eproto_2epb_2eh
