config.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: bin/mission_manager/config.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_bin_2fmission_5fmanager_2fconfig_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_bin_2fmission_5fmanager_2fconfig_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 3021012 < 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>
#include "goby/middleware/protobuf/app_config.pb.h"
#include "goby/zeromq/protobuf/interprocess_config.pb.h"
#include "goby/middleware/protobuf/transporter_config.pb.h"
#include "dccl/option_extensions.pb.h"
#include "jaiabot/messages/health.pb.h"
#include "jaiabot/messages/mission.pb.h"
#include "jaiabot/messages/camera_driver.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
 
#include <boost/units/systems/angle/degrees.hpp>
 
#include <boost/units/systems/si.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_bin_2fmission_5fmanager_2fconfig_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_bin_2fmission_5fmanager_2fconfig_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_bin_2fmission_5fmanager_2fconfig_2eproto;
namespace jaiabot {
namespace config {
class MissionManager;
struct MissionManagerDefaultTypeInternal;
extern MissionManagerDefaultTypeInternal _MissionManager_default_instance_;
class MissionManager_ResolveNoForwardProgress;
struct MissionManager_ResolveNoForwardProgressDefaultTypeInternal;
extern MissionManager_ResolveNoForwardProgressDefaultTypeInternal _MissionManager_ResolveNoForwardProgress_default_instance_;
}  // namespace config
}  // namespace jaiabot
PROTOBUF_NAMESPACE_OPEN
template<> ::jaiabot::config::MissionManager* Arena::CreateMaybeMessage<::jaiabot::config::MissionManager>(Arena*);
template<> ::jaiabot::config::MissionManager_ResolveNoForwardProgress* Arena::CreateMaybeMessage<::jaiabot::config::MissionManager_ResolveNoForwardProgress>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace jaiabot {
namespace config {
 
enum MissionManager_RemoteControlSetpointEnd : int {
  MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_STATIONKEEP = 1,
  MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_SURFACE_DRIFT = 2
};
bool MissionManager_RemoteControlSetpointEnd_IsValid(int value);
constexpr MissionManager_RemoteControlSetpointEnd MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_MIN = MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_STATIONKEEP;
constexpr MissionManager_RemoteControlSetpointEnd MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_MAX = MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_SURFACE_DRIFT;
constexpr int MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_ARRAYSIZE = MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MissionManager_RemoteControlSetpointEnd_descriptor();
template<typename T>
inline const std::string& MissionManager_RemoteControlSetpointEnd_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MissionManager_RemoteControlSetpointEnd>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MissionManager_RemoteControlSetpointEnd_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MissionManager_RemoteControlSetpointEnd_descriptor(), enum_t_value);
}
inline bool MissionManager_RemoteControlSetpointEnd_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MissionManager_RemoteControlSetpointEnd* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MissionManager_RemoteControlSetpointEnd>(
    MissionManager_RemoteControlSetpointEnd_descriptor(), name, value);
}
enum MissionManager_DownloadFileTypes : int {
  MissionManager_DownloadFileTypes_NONE = 1,
  MissionManager_DownloadFileTypes_GOBY = 2,
  MissionManager_DownloadFileTypes_TASKPACKET = 3
};
bool MissionManager_DownloadFileTypes_IsValid(int value);
constexpr MissionManager_DownloadFileTypes MissionManager_DownloadFileTypes_DownloadFileTypes_MIN = MissionManager_DownloadFileTypes_NONE;
constexpr MissionManager_DownloadFileTypes MissionManager_DownloadFileTypes_DownloadFileTypes_MAX = MissionManager_DownloadFileTypes_TASKPACKET;
constexpr int MissionManager_DownloadFileTypes_DownloadFileTypes_ARRAYSIZE = MissionManager_DownloadFileTypes_DownloadFileTypes_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MissionManager_DownloadFileTypes_descriptor();
template<typename T>
inline const std::string& MissionManager_DownloadFileTypes_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MissionManager_DownloadFileTypes>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MissionManager_DownloadFileTypes_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MissionManager_DownloadFileTypes_descriptor(), enum_t_value);
}
inline bool MissionManager_DownloadFileTypes_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MissionManager_DownloadFileTypes* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MissionManager_DownloadFileTypes>(
    MissionManager_DownloadFileTypes_descriptor(), name, value);
}
enum MissionManager_EngineeringTestMode : int {
  MissionManager_EngineeringTestMode_ENGINEERING_TEST__ALWAYS_LOG_EVEN_WHEN_IDLE = 1,
  MissionManager_EngineeringTestMode_ENGINEERING_TEST__IGNORE_SOME_ERRORS = 2,
  MissionManager_EngineeringTestMode_ENGINEERING_TEST__INDOOR_MODE__NO_GPS = 3
};
bool MissionManager_EngineeringTestMode_IsValid(int value);
constexpr MissionManager_EngineeringTestMode MissionManager_EngineeringTestMode_EngineeringTestMode_MIN = MissionManager_EngineeringTestMode_ENGINEERING_TEST__ALWAYS_LOG_EVEN_WHEN_IDLE;
constexpr MissionManager_EngineeringTestMode MissionManager_EngineeringTestMode_EngineeringTestMode_MAX = MissionManager_EngineeringTestMode_ENGINEERING_TEST__INDOOR_MODE__NO_GPS;
constexpr int MissionManager_EngineeringTestMode_EngineeringTestMode_ARRAYSIZE = MissionManager_EngineeringTestMode_EngineeringTestMode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MissionManager_EngineeringTestMode_descriptor();
template<typename T>
inline const std::string& MissionManager_EngineeringTestMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MissionManager_EngineeringTestMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MissionManager_EngineeringTestMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MissionManager_EngineeringTestMode_descriptor(), enum_t_value);
}
inline bool MissionManager_EngineeringTestMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MissionManager_EngineeringTestMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MissionManager_EngineeringTestMode>(
    MissionManager_EngineeringTestMode_descriptor(), name, value);
}
// ===================================================================
 
class MissionManager_ResolveNoForwardProgress final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.config.MissionManager.ResolveNoForwardProgress) */ {
 public:
  inline MissionManager_ResolveNoForwardProgress() : MissionManager_ResolveNoForwardProgress(nullptr) {}
  ~MissionManager_ResolveNoForwardProgress() override;
  explicit PROTOBUF_CONSTEXPR MissionManager_ResolveNoForwardProgress(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MissionManager_ResolveNoForwardProgress(const MissionManager_ResolveNoForwardProgress& from);
  MissionManager_ResolveNoForwardProgress(MissionManager_ResolveNoForwardProgress&& from) noexcept
    : MissionManager_ResolveNoForwardProgress() {
    *this = ::std::move(from);
  }
 
  inline MissionManager_ResolveNoForwardProgress& operator=(const MissionManager_ResolveNoForwardProgress& from) {
    CopyFrom(from);
    return *this;
  }
  inline MissionManager_ResolveNoForwardProgress& operator=(MissionManager_ResolveNoForwardProgress&& 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 MissionManager_ResolveNoForwardProgress& default_instance() {
    return *internal_default_instance();
  }
  static inline const MissionManager_ResolveNoForwardProgress* internal_default_instance() {
    return reinterpret_cast<const MissionManager_ResolveNoForwardProgress*>(
               &_MissionManager_ResolveNoForwardProgress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(MissionManager_ResolveNoForwardProgress& a, MissionManager_ResolveNoForwardProgress& b) {
    a.Swap(&b);
  }
  inline void Swap(MissionManager_ResolveNoForwardProgress* 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(MissionManager_ResolveNoForwardProgress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MissionManager_ResolveNoForwardProgress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MissionManager_ResolveNoForwardProgress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MissionManager_ResolveNoForwardProgress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MissionManager_ResolveNoForwardProgress& from) {
    MissionManager_ResolveNoForwardProgress::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(MissionManager_ResolveNoForwardProgress* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.config.MissionManager.ResolveNoForwardProgress";
  }
  protected:
  explicit MissionManager_ResolveNoForwardProgress(::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 {
    kDesiredSpeedThresholdFieldNumber = 3,
    kTriggerTimeoutFieldNumber = 4,
    kResumeTimeoutFieldNumber = 1,
    kPitchThresholdFieldNumber = 2,
  };
  // optional int32 desired_speed_threshold = 3 [default = 0, (.dccl.field) = {
  bool has_desired_speed_threshold() const;
  private:
  bool _internal_has_desired_speed_threshold() const;
  public:
  void clear_desired_speed_threshold();
  int32_t desired_speed_threshold() const;
  void set_desired_speed_threshold(int32_t value);
  private:
  int32_t _internal_desired_speed_threshold() const;
  void _internal_set_desired_speed_threshold(int32_t value);
  public:
 
  // optional int32 trigger_timeout = 4 [default = 15, (.dccl.field) = {
  bool has_trigger_timeout() const;
  private:
  bool _internal_has_trigger_timeout() const;
  public:
  void clear_trigger_timeout();
  int32_t trigger_timeout() const;
  void set_trigger_timeout(int32_t value);
  private:
  int32_t _internal_trigger_timeout() const;
  void _internal_set_trigger_timeout(int32_t value);
  public:
 
  // optional int32 resume_timeout = 1 [default = 10, (.dccl.field) = {
  bool has_resume_timeout() const;
  private:
  bool _internal_has_resume_timeout() const;
  public:
  void clear_resume_timeout();
  int32_t resume_timeout() const;
  void set_resume_timeout(int32_t value);
  private:
  int32_t _internal_resume_timeout() const;
  void _internal_set_resume_timeout(int32_t value);
  public:
 
  // optional int32 pitch_threshold = 2 [default = 30, (.dccl.field) = {
  bool has_pitch_threshold() const;
  private:
  bool _internal_has_pitch_threshold() const;
  public:
  void clear_pitch_threshold();
  int32_t pitch_threshold() const;
  void set_pitch_threshold(int32_t value);
  private:
  int32_t _internal_pitch_threshold() const;
  void _internal_set_pitch_threshold(int32_t value);
  public:
 
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type resume_timeout_dimension;
  
  typedef boost::units::unit<resume_timeout_dimension,boost::units::si::system> resume_timeout_unit;
  
  template<typename Quantity >
    void set_resume_timeout_with_units(Quantity value_w_units)
    { set_resume_timeout(boost::units::quantity<resume_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity resume_timeout_with_units() const
    { return Quantity(resume_timeout() * resume_timeout_unit()); };
  
  boost::units::quantity< resume_timeout_unit,google::protobuf::int32 > resume_timeout_with_units() const
    { return resume_timeout_with_units<boost::units::quantity< resume_timeout_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::plane_angle_dimension pitch_threshold_dimension;
  
  typedef boost::units::unit<pitch_threshold_dimension,boost::units::degree::system> pitch_threshold_unit;
  
  template<typename Quantity >
    void set_pitch_threshold_with_units(Quantity value_w_units)
    { set_pitch_threshold(boost::units::quantity<pitch_threshold_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity pitch_threshold_with_units() const
    { return Quantity(pitch_threshold() * pitch_threshold_unit()); };
  
  boost::units::quantity< pitch_threshold_unit,google::protobuf::int32 > pitch_threshold_with_units() const
    { return pitch_threshold_with_units<boost::units::quantity< pitch_threshold_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::length_base_dimension,1, boost::units::time_base_dimension,-1 >::type desired_speed_threshold_dimension;
  
  typedef boost::units::unit<desired_speed_threshold_dimension,boost::units::si::system> desired_speed_threshold_unit;
  
  template<typename Quantity >
    void set_desired_speed_threshold_with_units(Quantity value_w_units)
    { set_desired_speed_threshold(boost::units::quantity<desired_speed_threshold_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity desired_speed_threshold_with_units() const
    { return Quantity(desired_speed_threshold() * desired_speed_threshold_unit()); };
  
  boost::units::quantity< desired_speed_threshold_unit,google::protobuf::int32 > desired_speed_threshold_with_units() const
    { return desired_speed_threshold_with_units<boost::units::quantity< desired_speed_threshold_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type trigger_timeout_dimension;
  
  typedef boost::units::unit<trigger_timeout_dimension,boost::units::si::system> trigger_timeout_unit;
  
  template<typename Quantity >
    void set_trigger_timeout_with_units(Quantity value_w_units)
    { set_trigger_timeout(boost::units::quantity<trigger_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity trigger_timeout_with_units() const
    { return Quantity(trigger_timeout() * trigger_timeout_unit()); };
  
  boost::units::quantity< trigger_timeout_unit,google::protobuf::int32 > trigger_timeout_with_units() const
    { return trigger_timeout_with_units<boost::units::quantity< trigger_timeout_unit,google::protobuf::int32 > >(); };
  
  // @@protoc_insertion_point(class_scope:jaiabot.config.MissionManager.ResolveNoForwardProgress)
 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::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t desired_speed_threshold_;
    int32_t trigger_timeout_;
    int32_t resume_timeout_;
    int32_t pitch_threshold_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_bin_2fmission_5fmanager_2fconfig_2eproto;
};
// -------------------------------------------------------------------
 
class MissionManager final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:jaiabot.config.MissionManager) */ {
 public:
  inline MissionManager() : MissionManager(nullptr) {}
  ~MissionManager() override;
  explicit PROTOBUF_CONSTEXPR MissionManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  MissionManager(const MissionManager& from);
  MissionManager(MissionManager&& from) noexcept
    : MissionManager() {
    *this = ::std::move(from);
  }
 
  inline MissionManager& operator=(const MissionManager& from) {
    CopyFrom(from);
    return *this;
  }
  inline MissionManager& operator=(MissionManager&& 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 MissionManager& default_instance() {
    return *internal_default_instance();
  }
  static inline const MissionManager* internal_default_instance() {
    return reinterpret_cast<const MissionManager*>(
               &_MissionManager_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(MissionManager& a, MissionManager& b) {
    a.Swap(&b);
  }
  inline void Swap(MissionManager* 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(MissionManager* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  MissionManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MissionManager>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MissionManager& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MissionManager& from) {
    MissionManager::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(MissionManager* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "jaiabot.config.MissionManager";
  }
  protected:
  explicit MissionManager(::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 ----------------------------------------------------
 
  typedef MissionManager_ResolveNoForwardProgress ResolveNoForwardProgress;
 
  typedef MissionManager_RemoteControlSetpointEnd RemoteControlSetpointEnd;
  static constexpr RemoteControlSetpointEnd RC_SETPOINT_ENDS_IN_STATIONKEEP =
    MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_STATIONKEEP;
  static constexpr RemoteControlSetpointEnd RC_SETPOINT_ENDS_IN_SURFACE_DRIFT =
    MissionManager_RemoteControlSetpointEnd_RC_SETPOINT_ENDS_IN_SURFACE_DRIFT;
  static inline bool RemoteControlSetpointEnd_IsValid(int value) {
    return MissionManager_RemoteControlSetpointEnd_IsValid(value);
  }
  static constexpr RemoteControlSetpointEnd RemoteControlSetpointEnd_MIN =
    MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_MIN;
  static constexpr RemoteControlSetpointEnd RemoteControlSetpointEnd_MAX =
    MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_MAX;
  static constexpr int RemoteControlSetpointEnd_ARRAYSIZE =
    MissionManager_RemoteControlSetpointEnd_RemoteControlSetpointEnd_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RemoteControlSetpointEnd_descriptor() {
    return MissionManager_RemoteControlSetpointEnd_descriptor();
  }
  template<typename T>
  static inline const std::string& RemoteControlSetpointEnd_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RemoteControlSetpointEnd>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RemoteControlSetpointEnd_Name.");
    return MissionManager_RemoteControlSetpointEnd_Name(enum_t_value);
  }
  static inline bool RemoteControlSetpointEnd_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RemoteControlSetpointEnd* value) {
    return MissionManager_RemoteControlSetpointEnd_Parse(name, value);
  }
 
  typedef MissionManager_DownloadFileTypes DownloadFileTypes;
  static constexpr DownloadFileTypes NONE =
    MissionManager_DownloadFileTypes_NONE;
  static constexpr DownloadFileTypes GOBY =
    MissionManager_DownloadFileTypes_GOBY;
  static constexpr DownloadFileTypes TASKPACKET =
    MissionManager_DownloadFileTypes_TASKPACKET;
  static inline bool DownloadFileTypes_IsValid(int value) {
    return MissionManager_DownloadFileTypes_IsValid(value);
  }
  static constexpr DownloadFileTypes DownloadFileTypes_MIN =
    MissionManager_DownloadFileTypes_DownloadFileTypes_MIN;
  static constexpr DownloadFileTypes DownloadFileTypes_MAX =
    MissionManager_DownloadFileTypes_DownloadFileTypes_MAX;
  static constexpr int DownloadFileTypes_ARRAYSIZE =
    MissionManager_DownloadFileTypes_DownloadFileTypes_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DownloadFileTypes_descriptor() {
    return MissionManager_DownloadFileTypes_descriptor();
  }
  template<typename T>
  static inline const std::string& DownloadFileTypes_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DownloadFileTypes>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DownloadFileTypes_Name.");
    return MissionManager_DownloadFileTypes_Name(enum_t_value);
  }
  static inline bool DownloadFileTypes_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DownloadFileTypes* value) {
    return MissionManager_DownloadFileTypes_Parse(name, value);
  }
 
  typedef MissionManager_EngineeringTestMode EngineeringTestMode;
  static constexpr EngineeringTestMode ENGINEERING_TEST__ALWAYS_LOG_EVEN_WHEN_IDLE =
    MissionManager_EngineeringTestMode_ENGINEERING_TEST__ALWAYS_LOG_EVEN_WHEN_IDLE;
  static constexpr EngineeringTestMode ENGINEERING_TEST__IGNORE_SOME_ERRORS =
    MissionManager_EngineeringTestMode_ENGINEERING_TEST__IGNORE_SOME_ERRORS;
  static constexpr EngineeringTestMode ENGINEERING_TEST__INDOOR_MODE__NO_GPS =
    MissionManager_EngineeringTestMode_ENGINEERING_TEST__INDOOR_MODE__NO_GPS;
  static inline bool EngineeringTestMode_IsValid(int value) {
    return MissionManager_EngineeringTestMode_IsValid(value);
  }
  static constexpr EngineeringTestMode EngineeringTestMode_MIN =
    MissionManager_EngineeringTestMode_EngineeringTestMode_MIN;
  static constexpr EngineeringTestMode EngineeringTestMode_MAX =
    MissionManager_EngineeringTestMode_EngineeringTestMode_MAX;
  static constexpr int EngineeringTestMode_ARRAYSIZE =
    MissionManager_EngineeringTestMode_EngineeringTestMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  EngineeringTestMode_descriptor() {
    return MissionManager_EngineeringTestMode_descriptor();
  }
  template<typename T>
  static inline const std::string& EngineeringTestMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EngineeringTestMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EngineeringTestMode_Name.");
    return MissionManager_EngineeringTestMode_Name(enum_t_value);
  }
  static inline bool EngineeringTestMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EngineeringTestMode* value) {
    return MissionManager_EngineeringTestMode_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kIncludeGoalTimeoutStatesFieldNumber = 49,
    kTestModeFieldNumber = 80,
    kIgnoreErrorFieldNumber = 81,
    kDataPreoffloadScriptFieldNumber = 70,
    kDataPostoffloadScriptFieldNumber = 71,
    kLogDirFieldNumber = 72,
    kLogStagingDirFieldNumber = 73,
    kLogArchiveDirFieldNumber = 74,
    kAppFieldNumber = 1,
    kInterprocessFieldNumber = 2,
    kCommandSubCfgFieldNumber = 11,
    kContactUpdateSubCfgFieldNumber = 13,
    kResolveNoForwardProgressFieldNumber = 88,
    kStartCameraCommandFieldNumber = 90,
    kStopCameraCommandFieldNumber = 91,
    kFleetIdFieldNumber = 9,
    kBotIdFieldNumber = 10,
    kUseGoalTimeoutFieldNumber = 47,
    kSkipGoalTaskFieldNumber = 48,
    kIsSimFieldNumber = 82,
    kSubnetMaskFieldNumber = 89,
    kStartupTimeoutFieldNumber = 12,
    kPoweredAscentMotorOnTimeoutFieldNumber = 25,
    kPoweredAscentMotorOffTimeoutFieldNumber = 26,
    kDivePrepTimeoutFieldNumber = 27,
    kPoweredDescentTimeoutFieldNumber = 28,
    kDetectBottomLogicInitTimeoutFieldNumber = 29,
    kDetectBottomLogicAfterHoldTimeoutFieldNumber = 30,
    kDiveDepthEpsFieldNumber = 31,
    kBottomingTimeoutFieldNumber = 32,
    kDiveSurfaceEpsFieldNumber = 33,
    kTotalGpsFixChecksFieldNumber = 34,
    kTotalGpsDegradedFixChecksFieldNumber = 35,
    kGpsHdopFixFieldNumber = 36,
    kGpsPdopFixFieldNumber = 37,
    kGpsAfterDiveHdopFixFieldNumber = 39,
    kGpsAfterDivePdopFixFieldNumber = 40,
    kMinDepthSafetyFieldNumber = 41,
    kTotalAfterDiveGpsFixChecksFieldNumber = 38,
    kGoalTimeoutReacquireGpsAttemptsFieldNumber = 45,
    kGoalTimeoutBufferFactorFieldNumber = 44,
    kTpvHistoryMaxFieldNumber = 46,
    kRcSetpointEndFieldNumber = 50,
    kBotNotRisingTimeoutFieldNumber = 52,
    kImuRestartSecondsFieldNumber = 51,
    kMotorOnTimeIncrementFieldNumber = 53,
    kPoweredAscentThrottleFieldNumber = 55,
    kPoweredAscentThrottleIncrementFieldNumber = 56,
    kPoweredAscentThrottleMaxFieldNumber = 57,
    kMotorOnTimeMaxFieldNumber = 54,
    kPitchAngleChecksFieldNumber = 60,
    kPitchToDeterminePoweredAscentVerticalFieldNumber = 58,
    kPitchToDetermineDivePrepVerticalFieldNumber = 59,
    kPitchAngleMinCheckTimeFieldNumber = 61,
    kDiveEpsToDetermineDivingFieldNumber = 62,
    kDataOffloadExcludeFieldNumber = 75,
    kFailedStartupLogTimeoutFieldNumber = 85,
    kHardBottomTypeAccelerationFieldNumber = 84,
    kWaypointWithNoTaskSlipRadiusFieldNumber = 86,
    kWaypointWithTaskSlipRadiusFieldNumber = 87,
  };
  // repeated .jaiabot.protobuf.MissionState include_goal_timeout_states = 49;
  int include_goal_timeout_states_size() const;
  private:
  int _internal_include_goal_timeout_states_size() const;
  public:
  void clear_include_goal_timeout_states();
  private:
  ::jaiabot::protobuf::MissionState _internal_include_goal_timeout_states(int index) const;
  void _internal_add_include_goal_timeout_states(::jaiabot::protobuf::MissionState value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_include_goal_timeout_states();
  public:
  ::jaiabot::protobuf::MissionState include_goal_timeout_states(int index) const;
  void set_include_goal_timeout_states(int index, ::jaiabot::protobuf::MissionState value);
  void add_include_goal_timeout_states(::jaiabot::protobuf::MissionState value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& include_goal_timeout_states() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_include_goal_timeout_states();
 
  // repeated .jaiabot.config.MissionManager.EngineeringTestMode test_mode = 80;
  int test_mode_size() const;
  private:
  int _internal_test_mode_size() const;
  public:
  void clear_test_mode();
  private:
  ::jaiabot::config::MissionManager_EngineeringTestMode _internal_test_mode(int index) const;
  void _internal_add_test_mode(::jaiabot::config::MissionManager_EngineeringTestMode value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_test_mode();
  public:
  ::jaiabot::config::MissionManager_EngineeringTestMode test_mode(int index) const;
  void set_test_mode(int index, ::jaiabot::config::MissionManager_EngineeringTestMode value);
  void add_test_mode(::jaiabot::config::MissionManager_EngineeringTestMode value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& test_mode() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_test_mode();
 
  // repeated .jaiabot.protobuf.Error ignore_error = 81;
  int ignore_error_size() const;
  private:
  int _internal_ignore_error_size() const;
  public:
  void clear_ignore_error();
  private:
  ::jaiabot::protobuf::Error _internal_ignore_error(int index) const;
  void _internal_add_ignore_error(::jaiabot::protobuf::Error value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_ignore_error();
  public:
  ::jaiabot::protobuf::Error ignore_error(int index) const;
  void set_ignore_error(int index, ::jaiabot::protobuf::Error value);
  void add_ignore_error(::jaiabot::protobuf::Error value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& ignore_error() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_ignore_error();
 
  // required string data_preoffload_script = 70;
  bool has_data_preoffload_script() const;
  private:
  bool _internal_has_data_preoffload_script() const;
  public:
  void clear_data_preoffload_script();
  const std::string& data_preoffload_script() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data_preoffload_script(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data_preoffload_script();
  PROTOBUF_NODISCARD std::string* release_data_preoffload_script();
  void set_allocated_data_preoffload_script(std::string* data_preoffload_script);
  private:
  const std::string& _internal_data_preoffload_script() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data_preoffload_script(const std::string& value);
  std::string* _internal_mutable_data_preoffload_script();
  public:
 
  // required string data_postoffload_script = 71;
  bool has_data_postoffload_script() const;
  private:
  bool _internal_has_data_postoffload_script() const;
  public:
  void clear_data_postoffload_script();
  const std::string& data_postoffload_script() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data_postoffload_script(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data_postoffload_script();
  PROTOBUF_NODISCARD std::string* release_data_postoffload_script();
  void set_allocated_data_postoffload_script(std::string* data_postoffload_script);
  private:
  const std::string& _internal_data_postoffload_script() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data_postoffload_script(const std::string& value);
  std::string* _internal_mutable_data_postoffload_script();
  public:
 
  // required string log_dir = 72;
  bool has_log_dir() const;
  private:
  bool _internal_has_log_dir() const;
  public:
  void clear_log_dir();
  const std::string& log_dir() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_log_dir(ArgT0&& arg0, ArgT... args);
  std::string* mutable_log_dir();
  PROTOBUF_NODISCARD std::string* release_log_dir();
  void set_allocated_log_dir(std::string* log_dir);
  private:
  const std::string& _internal_log_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_dir(const std::string& value);
  std::string* _internal_mutable_log_dir();
  public:
 
  // optional string log_staging_dir = 73 [default = "/var/log/jaiabot/staging"];
  bool has_log_staging_dir() const;
  private:
  bool _internal_has_log_staging_dir() const;
  public:
  void clear_log_staging_dir();
  const std::string& log_staging_dir() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_log_staging_dir(ArgT0&& arg0, ArgT... args);
  std::string* mutable_log_staging_dir();
  PROTOBUF_NODISCARD std::string* release_log_staging_dir();
  void set_allocated_log_staging_dir(std::string* log_staging_dir);
  private:
  const std::string& _internal_log_staging_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_staging_dir(const std::string& value);
  std::string* _internal_mutable_log_staging_dir();
  public:
 
  // optional string log_archive_dir = 74 [default = "/var/log/jaiabot/archive"];
  bool has_log_archive_dir() const;
  private:
  bool _internal_has_log_archive_dir() const;
  public:
  void clear_log_archive_dir();
  const std::string& log_archive_dir() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_log_archive_dir(ArgT0&& arg0, ArgT... args);
  std::string* mutable_log_archive_dir();
  PROTOBUF_NODISCARD std::string* release_log_archive_dir();
  void set_allocated_log_archive_dir(std::string* log_archive_dir);
  private:
  const std::string& _internal_log_archive_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_archive_dir(const std::string& value);
  std::string* _internal_mutable_log_archive_dir();
  public:
 
  // optional .goby.middleware.protobuf.AppConfig app = 1;
  bool has_app() const;
  private:
  bool _internal_has_app() const;
  public:
  void clear_app();
  const ::goby::middleware::protobuf::AppConfig& app() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::AppConfig* release_app();
  ::goby::middleware::protobuf::AppConfig* mutable_app();
  void set_allocated_app(::goby::middleware::protobuf::AppConfig* app);
  private:
  const ::goby::middleware::protobuf::AppConfig& _internal_app() const;
  ::goby::middleware::protobuf::AppConfig* _internal_mutable_app();
  public:
  void unsafe_arena_set_allocated_app(
      ::goby::middleware::protobuf::AppConfig* app);
  ::goby::middleware::protobuf::AppConfig* unsafe_arena_release_app();
 
  // optional .goby.zeromq.protobuf.InterProcessPortalConfig interprocess = 2;
  bool has_interprocess() const;
  private:
  bool _internal_has_interprocess() const;
  public:
  void clear_interprocess();
  const ::goby::zeromq::protobuf::InterProcessPortalConfig& interprocess() const;
  PROTOBUF_NODISCARD ::goby::zeromq::protobuf::InterProcessPortalConfig* release_interprocess();
  ::goby::zeromq::protobuf::InterProcessPortalConfig* mutable_interprocess();
  void set_allocated_interprocess(::goby::zeromq::protobuf::InterProcessPortalConfig* interprocess);
  private:
  const ::goby::zeromq::protobuf::InterProcessPortalConfig& _internal_interprocess() const;
  ::goby::zeromq::protobuf::InterProcessPortalConfig* _internal_mutable_interprocess();
  public:
  void unsafe_arena_set_allocated_interprocess(
      ::goby::zeromq::protobuf::InterProcessPortalConfig* interprocess);
  ::goby::zeromq::protobuf::InterProcessPortalConfig* unsafe_arena_release_interprocess();
 
  // required .goby.middleware.protobuf.TransporterConfig command_sub_cfg = 11;
  bool has_command_sub_cfg() const;
  private:
  bool _internal_has_command_sub_cfg() const;
  public:
  void clear_command_sub_cfg();
  const ::goby::middleware::protobuf::TransporterConfig& command_sub_cfg() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TransporterConfig* release_command_sub_cfg();
  ::goby::middleware::protobuf::TransporterConfig* mutable_command_sub_cfg();
  void set_allocated_command_sub_cfg(::goby::middleware::protobuf::TransporterConfig* command_sub_cfg);
  private:
  const ::goby::middleware::protobuf::TransporterConfig& _internal_command_sub_cfg() const;
  ::goby::middleware::protobuf::TransporterConfig* _internal_mutable_command_sub_cfg();
  public:
  void unsafe_arena_set_allocated_command_sub_cfg(
      ::goby::middleware::protobuf::TransporterConfig* command_sub_cfg);
  ::goby::middleware::protobuf::TransporterConfig* unsafe_arena_release_command_sub_cfg();
 
  // optional .goby.middleware.protobuf.TransporterConfig contact_update_sub_cfg = 13;
  bool has_contact_update_sub_cfg() const;
  private:
  bool _internal_has_contact_update_sub_cfg() const;
  public:
  void clear_contact_update_sub_cfg();
  const ::goby::middleware::protobuf::TransporterConfig& contact_update_sub_cfg() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TransporterConfig* release_contact_update_sub_cfg();
  ::goby::middleware::protobuf::TransporterConfig* mutable_contact_update_sub_cfg();
  void set_allocated_contact_update_sub_cfg(::goby::middleware::protobuf::TransporterConfig* contact_update_sub_cfg);
  private:
  const ::goby::middleware::protobuf::TransporterConfig& _internal_contact_update_sub_cfg() const;
  ::goby::middleware::protobuf::TransporterConfig* _internal_mutable_contact_update_sub_cfg();
  public:
  void unsafe_arena_set_allocated_contact_update_sub_cfg(
      ::goby::middleware::protobuf::TransporterConfig* contact_update_sub_cfg);
  ::goby::middleware::protobuf::TransporterConfig* unsafe_arena_release_contact_update_sub_cfg();
 
  // optional .jaiabot.config.MissionManager.ResolveNoForwardProgress resolve_no_forward_progress = 88;
  bool has_resolve_no_forward_progress() const;
  private:
  bool _internal_has_resolve_no_forward_progress() const;
  public:
  void clear_resolve_no_forward_progress();
  const ::jaiabot::config::MissionManager_ResolveNoForwardProgress& resolve_no_forward_progress() const;
  PROTOBUF_NODISCARD ::jaiabot::config::MissionManager_ResolveNoForwardProgress* release_resolve_no_forward_progress();
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* mutable_resolve_no_forward_progress();
  void set_allocated_resolve_no_forward_progress(::jaiabot::config::MissionManager_ResolveNoForwardProgress* resolve_no_forward_progress);
  private:
  const ::jaiabot::config::MissionManager_ResolveNoForwardProgress& _internal_resolve_no_forward_progress() const;
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* _internal_mutable_resolve_no_forward_progress();
  public:
  void unsafe_arena_set_allocated_resolve_no_forward_progress(
      ::jaiabot::config::MissionManager_ResolveNoForwardProgress* resolve_no_forward_progress);
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* unsafe_arena_release_resolve_no_forward_progress();
 
  // optional .jaiabot.protobuf.CameraCommand start_camera_command = 90;
  bool has_start_camera_command() const;
  private:
  bool _internal_has_start_camera_command() const;
  public:
  void clear_start_camera_command();
  const ::jaiabot::protobuf::CameraCommand& start_camera_command() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::CameraCommand* release_start_camera_command();
  ::jaiabot::protobuf::CameraCommand* mutable_start_camera_command();
  void set_allocated_start_camera_command(::jaiabot::protobuf::CameraCommand* start_camera_command);
  private:
  const ::jaiabot::protobuf::CameraCommand& _internal_start_camera_command() const;
  ::jaiabot::protobuf::CameraCommand* _internal_mutable_start_camera_command();
  public:
  void unsafe_arena_set_allocated_start_camera_command(
      ::jaiabot::protobuf::CameraCommand* start_camera_command);
  ::jaiabot::protobuf::CameraCommand* unsafe_arena_release_start_camera_command();
 
  // optional .jaiabot.protobuf.CameraCommand stop_camera_command = 91;
  bool has_stop_camera_command() const;
  private:
  bool _internal_has_stop_camera_command() const;
  public:
  void clear_stop_camera_command();
  const ::jaiabot::protobuf::CameraCommand& stop_camera_command() const;
  PROTOBUF_NODISCARD ::jaiabot::protobuf::CameraCommand* release_stop_camera_command();
  ::jaiabot::protobuf::CameraCommand* mutable_stop_camera_command();
  void set_allocated_stop_camera_command(::jaiabot::protobuf::CameraCommand* stop_camera_command);
  private:
  const ::jaiabot::protobuf::CameraCommand& _internal_stop_camera_command() const;
  ::jaiabot::protobuf::CameraCommand* _internal_mutable_stop_camera_command();
  public:
  void unsafe_arena_set_allocated_stop_camera_command(
      ::jaiabot::protobuf::CameraCommand* stop_camera_command);
  ::jaiabot::protobuf::CameraCommand* unsafe_arena_release_stop_camera_command();
 
  // required int32 fleet_id = 9;
  bool has_fleet_id() const;
  private:
  bool _internal_has_fleet_id() const;
  public:
  void clear_fleet_id();
  int32_t fleet_id() const;
  void set_fleet_id(int32_t value);
  private:
  int32_t _internal_fleet_id() const;
  void _internal_set_fleet_id(int32_t value);
  public:
 
  // required int32 bot_id = 10;
  bool has_bot_id() const;
  private:
  bool _internal_has_bot_id() const;
  public:
  void clear_bot_id();
  int32_t bot_id() const;
  void set_bot_id(int32_t value);
  private:
  int32_t _internal_bot_id() const;
  void _internal_set_bot_id(int32_t value);
  public:
 
  // optional bool use_goal_timeout = 47 [default = false];
  bool has_use_goal_timeout() const;
  private:
  bool _internal_has_use_goal_timeout() const;
  public:
  void clear_use_goal_timeout();
  bool use_goal_timeout() const;
  void set_use_goal_timeout(bool value);
  private:
  bool _internal_use_goal_timeout() const;
  void _internal_set_use_goal_timeout(bool value);
  public:
 
  // optional bool skip_goal_task = 48 [default = false];
  bool has_skip_goal_task() const;
  private:
  bool _internal_has_skip_goal_task() const;
  public:
  void clear_skip_goal_task();
  bool skip_goal_task() const;
  void set_skip_goal_task(bool value);
  private:
  bool _internal_skip_goal_task() const;
  void _internal_set_skip_goal_task(bool value);
  public:
 
  // optional bool is_sim = 82 [default = false];
  bool has_is_sim() const;
  private:
  bool _internal_has_is_sim() const;
  public:
  void clear_is_sim();
  bool is_sim() const;
  void set_is_sim(bool value);
  private:
  bool _internal_is_sim() const;
  void _internal_set_is_sim(bool value);
  public:
 
  // required uint32 subnet_mask = 89;
  bool has_subnet_mask() const;
  private:
  bool _internal_has_subnet_mask() const;
  public:
  void clear_subnet_mask();
  uint32_t subnet_mask() const;
  void set_subnet_mask(uint32_t value);
  private:
  uint32_t _internal_subnet_mask() const;
  void _internal_set_subnet_mask(uint32_t value);
  public:
 
  // optional double startup_timeout = 12 [default = 120, (.dccl.field) = {
  bool has_startup_timeout() const;
  private:
  bool _internal_has_startup_timeout() const;
  public:
  void clear_startup_timeout();
  double startup_timeout() const;
  void set_startup_timeout(double value);
  private:
  double _internal_startup_timeout() const;
  void _internal_set_startup_timeout(double value);
  public:
 
  // optional int32 powered_ascent_motor_on_timeout = 25 [default = 5, (.dccl.field) = {
  bool has_powered_ascent_motor_on_timeout() const;
  private:
  bool _internal_has_powered_ascent_motor_on_timeout() const;
  public:
  void clear_powered_ascent_motor_on_timeout();
  int32_t powered_ascent_motor_on_timeout() const;
  void set_powered_ascent_motor_on_timeout(int32_t value);
  private:
  int32_t _internal_powered_ascent_motor_on_timeout() const;
  void _internal_set_powered_ascent_motor_on_timeout(int32_t value);
  public:
 
  // optional int32 powered_ascent_motor_off_timeout = 26 [default = 2, (.dccl.field) = {
  bool has_powered_ascent_motor_off_timeout() const;
  private:
  bool _internal_has_powered_ascent_motor_off_timeout() const;
  public:
  void clear_powered_ascent_motor_off_timeout();
  int32_t powered_ascent_motor_off_timeout() const;
  void set_powered_ascent_motor_off_timeout(int32_t value);
  private:
  int32_t _internal_powered_ascent_motor_off_timeout() const;
  void _internal_set_powered_ascent_motor_off_timeout(int32_t value);
  public:
 
  // optional int32 dive_prep_timeout = 27 [default = 10, (.dccl.field) = {
  bool has_dive_prep_timeout() const;
  private:
  bool _internal_has_dive_prep_timeout() const;
  public:
  void clear_dive_prep_timeout();
  int32_t dive_prep_timeout() const;
  void set_dive_prep_timeout(int32_t value);
  private:
  int32_t _internal_dive_prep_timeout() const;
  void _internal_set_dive_prep_timeout(int32_t value);
  public:
 
  // optional int32 powered_descent_timeout = 28 [default = 100, (.dccl.field) = {
  bool has_powered_descent_timeout() const;
  private:
  bool _internal_has_powered_descent_timeout() const;
  public:
  void clear_powered_descent_timeout();
  int32_t powered_descent_timeout() const;
  void set_powered_descent_timeout(int32_t value);
  private:
  int32_t _internal_powered_descent_timeout() const;
  void _internal_set_powered_descent_timeout(int32_t value);
  public:
 
  // optional double detect_bottom_logic_init_timeout = 29 [default = 15, (.dccl.field) = {
  bool has_detect_bottom_logic_init_timeout() const;
  private:
  bool _internal_has_detect_bottom_logic_init_timeout() const;
  public:
  void clear_detect_bottom_logic_init_timeout();
  double detect_bottom_logic_init_timeout() const;
  void set_detect_bottom_logic_init_timeout(double value);
  private:
  double _internal_detect_bottom_logic_init_timeout() const;
  void _internal_set_detect_bottom_logic_init_timeout(double value);
  public:
 
  // optional double detect_bottom_logic_after_hold_timeout = 30 [default = 5, (.dccl.field) = {
  bool has_detect_bottom_logic_after_hold_timeout() const;
  private:
  bool _internal_has_detect_bottom_logic_after_hold_timeout() const;
  public:
  void clear_detect_bottom_logic_after_hold_timeout();
  double detect_bottom_logic_after_hold_timeout() const;
  void set_detect_bottom_logic_after_hold_timeout(double value);
  private:
  double _internal_detect_bottom_logic_after_hold_timeout() const;
  void _internal_set_detect_bottom_logic_after_hold_timeout(double value);
  public:
 
  // optional double dive_depth_eps = 31 [default = 0.1, (.dccl.field) = {
  bool has_dive_depth_eps() const;
  private:
  bool _internal_has_dive_depth_eps() const;
  public:
  void clear_dive_depth_eps();
  double dive_depth_eps() const;
  void set_dive_depth_eps(double value);
  private:
  double _internal_dive_depth_eps() const;
  void _internal_set_dive_depth_eps(double value);
  public:
 
  // optional double bottoming_timeout = 32 [default = 3, (.dccl.field) = {
  bool has_bottoming_timeout() const;
  private:
  bool _internal_has_bottoming_timeout() const;
  public:
  void clear_bottoming_timeout();
  double bottoming_timeout() const;
  void set_bottoming_timeout(double value);
  private:
  double _internal_bottoming_timeout() const;
  void _internal_set_bottoming_timeout(double value);
  public:
 
  // optional double dive_surface_eps = 33 [default = 0.75, (.dccl.field) = {
  bool has_dive_surface_eps() const;
  private:
  bool _internal_has_dive_surface_eps() const;
  public:
  void clear_dive_surface_eps();
  double dive_surface_eps() const;
  void set_dive_surface_eps(double value);
  private:
  double _internal_dive_surface_eps() const;
  void _internal_set_dive_surface_eps(double value);
  public:
 
  // optional uint32 total_gps_fix_checks = 34 [default = 10];
  bool has_total_gps_fix_checks() const;
  private:
  bool _internal_has_total_gps_fix_checks() const;
  public:
  void clear_total_gps_fix_checks();
  uint32_t total_gps_fix_checks() const;
  void set_total_gps_fix_checks(uint32_t value);
  private:
  uint32_t _internal_total_gps_fix_checks() const;
  void _internal_set_total_gps_fix_checks(uint32_t value);
  public:
 
  // optional uint32 total_gps_degraded_fix_checks = 35 [default = 2];
  bool has_total_gps_degraded_fix_checks() const;
  private:
  bool _internal_has_total_gps_degraded_fix_checks() const;
  public:
  void clear_total_gps_degraded_fix_checks();
  uint32_t total_gps_degraded_fix_checks() const;
  void set_total_gps_degraded_fix_checks(uint32_t value);
  private:
  uint32_t _internal_total_gps_degraded_fix_checks() const;
  void _internal_set_total_gps_degraded_fix_checks(uint32_t value);
  public:
 
  // optional double gps_hdop_fix = 36 [default = 1.3];
  bool has_gps_hdop_fix() const;
  private:
  bool _internal_has_gps_hdop_fix() const;
  public:
  void clear_gps_hdop_fix();
  double gps_hdop_fix() const;
  void set_gps_hdop_fix(double value);
  private:
  double _internal_gps_hdop_fix() const;
  void _internal_set_gps_hdop_fix(double value);
  public:
 
  // optional double gps_pdop_fix = 37 [default = 2.2];
  bool has_gps_pdop_fix() const;
  private:
  bool _internal_has_gps_pdop_fix() const;
  public:
  void clear_gps_pdop_fix();
  double gps_pdop_fix() const;
  void set_gps_pdop_fix(double value);
  private:
  double _internal_gps_pdop_fix() const;
  void _internal_set_gps_pdop_fix(double value);
  public:
 
  // optional double gps_after_dive_hdop_fix = 39 [default = 1.3];
  bool has_gps_after_dive_hdop_fix() const;
  private:
  bool _internal_has_gps_after_dive_hdop_fix() const;
  public:
  void clear_gps_after_dive_hdop_fix();
  double gps_after_dive_hdop_fix() const;
  void set_gps_after_dive_hdop_fix(double value);
  private:
  double _internal_gps_after_dive_hdop_fix() const;
  void _internal_set_gps_after_dive_hdop_fix(double value);
  public:
 
  // optional double gps_after_dive_pdop_fix = 40 [default = 2.2];
  bool has_gps_after_dive_pdop_fix() const;
  private:
  bool _internal_has_gps_after_dive_pdop_fix() const;
  public:
  void clear_gps_after_dive_pdop_fix();
  double gps_after_dive_pdop_fix() const;
  void set_gps_after_dive_pdop_fix(double value);
  private:
  double _internal_gps_after_dive_pdop_fix() const;
  void _internal_set_gps_after_dive_pdop_fix(double value);
  public:
 
  // optional double min_depth_safety = 41 [default = -1];
  bool has_min_depth_safety() const;
  private:
  bool _internal_has_min_depth_safety() const;
  public:
  void clear_min_depth_safety();
  double min_depth_safety() const;
  void set_min_depth_safety(double value);
  private:
  double _internal_min_depth_safety() const;
  void _internal_set_min_depth_safety(double value);
  public:
 
  // optional uint32 total_after_dive_gps_fix_checks = 38 [default = 15];
  bool has_total_after_dive_gps_fix_checks() const;
  private:
  bool _internal_has_total_after_dive_gps_fix_checks() const;
  public:
  void clear_total_after_dive_gps_fix_checks();
  uint32_t total_after_dive_gps_fix_checks() const;
  void set_total_after_dive_gps_fix_checks(uint32_t value);
  private:
  uint32_t _internal_total_after_dive_gps_fix_checks() const;
  void _internal_set_total_after_dive_gps_fix_checks(uint32_t value);
  public:
 
  // optional uint32 goal_timeout_reacquire_gps_attempts = 45 [default = 2];
  bool has_goal_timeout_reacquire_gps_attempts() const;
  private:
  bool _internal_has_goal_timeout_reacquire_gps_attempts() const;
  public:
  void clear_goal_timeout_reacquire_gps_attempts();
  uint32_t goal_timeout_reacquire_gps_attempts() const;
  void set_goal_timeout_reacquire_gps_attempts(uint32_t value);
  private:
  uint32_t _internal_goal_timeout_reacquire_gps_attempts() const;
  void _internal_set_goal_timeout_reacquire_gps_attempts(uint32_t value);
  public:
 
  // optional double goal_timeout_buffer_factor = 44 [default = 1];
  bool has_goal_timeout_buffer_factor() const;
  private:
  bool _internal_has_goal_timeout_buffer_factor() const;
  public:
  void clear_goal_timeout_buffer_factor();
  double goal_timeout_buffer_factor() const;
  void set_goal_timeout_buffer_factor(double value);
  private:
  double _internal_goal_timeout_buffer_factor() const;
  void _internal_set_goal_timeout_buffer_factor(double value);
  public:
 
  // optional uint32 tpv_history_max = 46 [default = 15];
  bool has_tpv_history_max() const;
  private:
  bool _internal_has_tpv_history_max() const;
  public:
  void clear_tpv_history_max();
  uint32_t tpv_history_max() const;
  void set_tpv_history_max(uint32_t value);
  private:
  uint32_t _internal_tpv_history_max() const;
  void _internal_set_tpv_history_max(uint32_t value);
  public:
 
  // optional .jaiabot.config.MissionManager.RemoteControlSetpointEnd rc_setpoint_end = 50 [default = RC_SETPOINT_ENDS_IN_STATIONKEEP];
  bool has_rc_setpoint_end() const;
  private:
  bool _internal_has_rc_setpoint_end() const;
  public:
  void clear_rc_setpoint_end();
  ::jaiabot::config::MissionManager_RemoteControlSetpointEnd rc_setpoint_end() const;
  void set_rc_setpoint_end(::jaiabot::config::MissionManager_RemoteControlSetpointEnd value);
  private:
  ::jaiabot::config::MissionManager_RemoteControlSetpointEnd _internal_rc_setpoint_end() const;
  void _internal_set_rc_setpoint_end(::jaiabot::config::MissionManager_RemoteControlSetpointEnd value);
  public:
 
  // optional double bot_not_rising_timeout = 52 [default = 6, (.dccl.field) = {
  bool has_bot_not_rising_timeout() const;
  private:
  bool _internal_has_bot_not_rising_timeout() const;
  public:
  void clear_bot_not_rising_timeout();
  double bot_not_rising_timeout() const;
  void set_bot_not_rising_timeout(double value);
  private:
  double _internal_bot_not_rising_timeout() const;
  void _internal_set_bot_not_rising_timeout(double value);
  public:
 
  // optional uint32 imu_restart_seconds = 51 [default = 15];
  bool has_imu_restart_seconds() const;
  private:
  bool _internal_has_imu_restart_seconds() const;
  public:
  void clear_imu_restart_seconds();
  uint32_t imu_restart_seconds() const;
  void set_imu_restart_seconds(uint32_t value);
  private:
  uint32_t _internal_imu_restart_seconds() const;
  void _internal_set_imu_restart_seconds(uint32_t value);
  public:
 
  // optional int32 motor_on_time_increment = 53 [default = 1, (.dccl.field) = {
  bool has_motor_on_time_increment() const;
  private:
  bool _internal_has_motor_on_time_increment() const;
  public:
  void clear_motor_on_time_increment();
  int32_t motor_on_time_increment() const;
  void set_motor_on_time_increment(int32_t value);
  private:
  int32_t _internal_motor_on_time_increment() const;
  void _internal_set_motor_on_time_increment(int32_t value);
  public:
 
  // optional double powered_ascent_throttle = 55 [default = 25];
  bool has_powered_ascent_throttle() const;
  private:
  bool _internal_has_powered_ascent_throttle() const;
  public:
  void clear_powered_ascent_throttle();
  double powered_ascent_throttle() const;
  void set_powered_ascent_throttle(double value);
  private:
  double _internal_powered_ascent_throttle() const;
  void _internal_set_powered_ascent_throttle(double value);
  public:
 
  // optional double powered_ascent_throttle_increment = 56 [default = 5];
  bool has_powered_ascent_throttle_increment() const;
  private:
  bool _internal_has_powered_ascent_throttle_increment() const;
  public:
  void clear_powered_ascent_throttle_increment();
  double powered_ascent_throttle_increment() const;
  void set_powered_ascent_throttle_increment(double value);
  private:
  double _internal_powered_ascent_throttle_increment() const;
  void _internal_set_powered_ascent_throttle_increment(double value);
  public:
 
  // optional double powered_ascent_throttle_max = 57 [default = 60];
  bool has_powered_ascent_throttle_max() const;
  private:
  bool _internal_has_powered_ascent_throttle_max() const;
  public:
  void clear_powered_ascent_throttle_max();
  double powered_ascent_throttle_max() const;
  void set_powered_ascent_throttle_max(double value);
  private:
  double _internal_powered_ascent_throttle_max() const;
  void _internal_set_powered_ascent_throttle_max(double value);
  public:
 
  // optional int32 motor_on_time_max = 54 [default = 10, (.dccl.field) = {
  bool has_motor_on_time_max() const;
  private:
  bool _internal_has_motor_on_time_max() const;
  public:
  void clear_motor_on_time_max();
  int32_t motor_on_time_max() const;
  void set_motor_on_time_max(int32_t value);
  private:
  int32_t _internal_motor_on_time_max() const;
  void _internal_set_motor_on_time_max(int32_t value);
  public:
 
  // optional int32 pitch_angle_checks = 60 [default = 3];
  bool has_pitch_angle_checks() const;
  private:
  bool _internal_has_pitch_angle_checks() const;
  public:
  void clear_pitch_angle_checks();
  int32_t pitch_angle_checks() const;
  void set_pitch_angle_checks(int32_t value);
  private:
  int32_t _internal_pitch_angle_checks() const;
  void _internal_set_pitch_angle_checks(int32_t value);
  public:
 
  // optional double pitch_to_determine_powered_ascent_vertical = 58 [default = 30];
  bool has_pitch_to_determine_powered_ascent_vertical() const;
  private:
  bool _internal_has_pitch_to_determine_powered_ascent_vertical() const;
  public:
  void clear_pitch_to_determine_powered_ascent_vertical();
  double pitch_to_determine_powered_ascent_vertical() const;
  void set_pitch_to_determine_powered_ascent_vertical(double value);
  private:
  double _internal_pitch_to_determine_powered_ascent_vertical() const;
  void _internal_set_pitch_to_determine_powered_ascent_vertical(double value);
  public:
 
  // optional double pitch_to_determine_dive_prep_vertical = 59 [default = 70];
  bool has_pitch_to_determine_dive_prep_vertical() const;
  private:
  bool _internal_has_pitch_to_determine_dive_prep_vertical() const;
  public:
  void clear_pitch_to_determine_dive_prep_vertical();
  double pitch_to_determine_dive_prep_vertical() const;
  void set_pitch_to_determine_dive_prep_vertical(double value);
  private:
  double _internal_pitch_to_determine_dive_prep_vertical() const;
  void _internal_set_pitch_to_determine_dive_prep_vertical(double value);
  public:
 
  // optional double pitch_angle_min_check_time = 61 [default = 1, (.dccl.field) = {
  bool has_pitch_angle_min_check_time() const;
  private:
  bool _internal_has_pitch_angle_min_check_time() const;
  public:
  void clear_pitch_angle_min_check_time();
  double pitch_angle_min_check_time() const;
  void set_pitch_angle_min_check_time(double value);
  private:
  double _internal_pitch_angle_min_check_time() const;
  void _internal_set_pitch_angle_min_check_time(double value);
  public:
 
  // optional double dive_eps_to_determine_diving = 62 [default = 0.3, (.dccl.field) = {
  bool has_dive_eps_to_determine_diving() const;
  private:
  bool _internal_has_dive_eps_to_determine_diving() const;
  public:
  void clear_dive_eps_to_determine_diving();
  double dive_eps_to_determine_diving() const;
  void set_dive_eps_to_determine_diving(double value);
  private:
  double _internal_dive_eps_to_determine_diving() const;
  void _internal_set_dive_eps_to_determine_diving(double value);
  public:
 
  // optional .jaiabot.config.MissionManager.DownloadFileTypes data_offload_exclude = 75;
  bool has_data_offload_exclude() const;
  private:
  bool _internal_has_data_offload_exclude() const;
  public:
  void clear_data_offload_exclude();
  ::jaiabot::config::MissionManager_DownloadFileTypes data_offload_exclude() const;
  void set_data_offload_exclude(::jaiabot::config::MissionManager_DownloadFileTypes value);
  private:
  ::jaiabot::config::MissionManager_DownloadFileTypes _internal_data_offload_exclude() const;
  void _internal_set_data_offload_exclude(::jaiabot::config::MissionManager_DownloadFileTypes value);
  public:
 
  // optional int32 failed_startup_log_timeout = 85 [default = 300, (.dccl.field) = {
  bool has_failed_startup_log_timeout() const;
  private:
  bool _internal_has_failed_startup_log_timeout() const;
  public:
  void clear_failed_startup_log_timeout();
  int32_t failed_startup_log_timeout() const;
  void set_failed_startup_log_timeout(int32_t value);
  private:
  int32_t _internal_failed_startup_log_timeout() const;
  void _internal_set_failed_startup_log_timeout(int32_t value);
  public:
 
  // optional double hard_bottom_type_acceleration = 84 [default = 100];
  bool has_hard_bottom_type_acceleration() const;
  private:
  bool _internal_has_hard_bottom_type_acceleration() const;
  public:
  void clear_hard_bottom_type_acceleration();
  double hard_bottom_type_acceleration() const;
  void set_hard_bottom_type_acceleration(double value);
  private:
  double _internal_hard_bottom_type_acceleration() const;
  void _internal_set_hard_bottom_type_acceleration(double value);
  public:
 
  // optional int32 waypoint_with_no_task_slip_radius = 86 [default = 15];
  bool has_waypoint_with_no_task_slip_radius() const;
  private:
  bool _internal_has_waypoint_with_no_task_slip_radius() const;
  public:
  void clear_waypoint_with_no_task_slip_radius();
  int32_t waypoint_with_no_task_slip_radius() const;
  void set_waypoint_with_no_task_slip_radius(int32_t value);
  private:
  int32_t _internal_waypoint_with_no_task_slip_radius() const;
  void _internal_set_waypoint_with_no_task_slip_radius(int32_t value);
  public:
 
  // optional int32 waypoint_with_task_slip_radius = 87 [default = 5];
  bool has_waypoint_with_task_slip_radius() const;
  private:
  bool _internal_has_waypoint_with_task_slip_radius() const;
  public:
  void clear_waypoint_with_task_slip_radius();
  int32_t waypoint_with_task_slip_radius() const;
  void set_waypoint_with_task_slip_radius(int32_t value);
  private:
  int32_t _internal_waypoint_with_task_slip_radius() const;
  void _internal_set_waypoint_with_task_slip_radius(int32_t value);
  public:
 
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type startup_timeout_dimension;
  
  typedef boost::units::unit<startup_timeout_dimension,boost::units::si::system> startup_timeout_unit;
  
  template<typename Quantity >
    void set_startup_timeout_with_units(Quantity value_w_units)
    { set_startup_timeout(boost::units::quantity<startup_timeout_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity startup_timeout_with_units() const
    { return Quantity(startup_timeout() * startup_timeout_unit()); };
  
  boost::units::quantity< startup_timeout_unit,double > startup_timeout_with_units() const
    { return startup_timeout_with_units<boost::units::quantity< startup_timeout_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type powered_ascent_motor_on_timeout_dimension;
  
  typedef boost::units::unit<powered_ascent_motor_on_timeout_dimension,boost::units::si::system> powered_ascent_motor_on_timeout_unit;
  
  template<typename Quantity >
    void set_powered_ascent_motor_on_timeout_with_units(Quantity value_w_units)
    { set_powered_ascent_motor_on_timeout(boost::units::quantity<powered_ascent_motor_on_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity powered_ascent_motor_on_timeout_with_units() const
    { return Quantity(powered_ascent_motor_on_timeout() * powered_ascent_motor_on_timeout_unit()); };
  
  boost::units::quantity< powered_ascent_motor_on_timeout_unit,google::protobuf::int32 > powered_ascent_motor_on_timeout_with_units() const
    { return powered_ascent_motor_on_timeout_with_units<boost::units::quantity< powered_ascent_motor_on_timeout_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type powered_ascent_motor_off_timeout_dimension;
  
  typedef boost::units::unit<powered_ascent_motor_off_timeout_dimension,boost::units::si::system> powered_ascent_motor_off_timeout_unit;
  
  template<typename Quantity >
    void set_powered_ascent_motor_off_timeout_with_units(Quantity value_w_units)
    { set_powered_ascent_motor_off_timeout(boost::units::quantity<powered_ascent_motor_off_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity powered_ascent_motor_off_timeout_with_units() const
    { return Quantity(powered_ascent_motor_off_timeout() * powered_ascent_motor_off_timeout_unit()); };
  
  boost::units::quantity< powered_ascent_motor_off_timeout_unit,google::protobuf::int32 > powered_ascent_motor_off_timeout_with_units() const
    { return powered_ascent_motor_off_timeout_with_units<boost::units::quantity< powered_ascent_motor_off_timeout_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type dive_prep_timeout_dimension;
  
  typedef boost::units::unit<dive_prep_timeout_dimension,boost::units::si::system> dive_prep_timeout_unit;
  
  template<typename Quantity >
    void set_dive_prep_timeout_with_units(Quantity value_w_units)
    { set_dive_prep_timeout(boost::units::quantity<dive_prep_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity dive_prep_timeout_with_units() const
    { return Quantity(dive_prep_timeout() * dive_prep_timeout_unit()); };
  
  boost::units::quantity< dive_prep_timeout_unit,google::protobuf::int32 > dive_prep_timeout_with_units() const
    { return dive_prep_timeout_with_units<boost::units::quantity< dive_prep_timeout_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type powered_descent_timeout_dimension;
  
  typedef boost::units::unit<powered_descent_timeout_dimension,boost::units::si::system> powered_descent_timeout_unit;
  
  template<typename Quantity >
    void set_powered_descent_timeout_with_units(Quantity value_w_units)
    { set_powered_descent_timeout(boost::units::quantity<powered_descent_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity powered_descent_timeout_with_units() const
    { return Quantity(powered_descent_timeout() * powered_descent_timeout_unit()); };
  
  boost::units::quantity< powered_descent_timeout_unit,google::protobuf::int32 > powered_descent_timeout_with_units() const
    { return powered_descent_timeout_with_units<boost::units::quantity< powered_descent_timeout_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type detect_bottom_logic_init_timeout_dimension;
  
  typedef boost::units::unit<detect_bottom_logic_init_timeout_dimension,boost::units::si::system> detect_bottom_logic_init_timeout_unit;
  
  template<typename Quantity >
    void set_detect_bottom_logic_init_timeout_with_units(Quantity value_w_units)
    { set_detect_bottom_logic_init_timeout(boost::units::quantity<detect_bottom_logic_init_timeout_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity detect_bottom_logic_init_timeout_with_units() const
    { return Quantity(detect_bottom_logic_init_timeout() * detect_bottom_logic_init_timeout_unit()); };
  
  boost::units::quantity< detect_bottom_logic_init_timeout_unit,double > detect_bottom_logic_init_timeout_with_units() const
    { return detect_bottom_logic_init_timeout_with_units<boost::units::quantity< detect_bottom_logic_init_timeout_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type detect_bottom_logic_after_hold_timeout_dimension;
  
  typedef boost::units::unit<detect_bottom_logic_after_hold_timeout_dimension,boost::units::si::system> detect_bottom_logic_after_hold_timeout_unit;
  
  template<typename Quantity >
    void set_detect_bottom_logic_after_hold_timeout_with_units(Quantity value_w_units)
    { set_detect_bottom_logic_after_hold_timeout(boost::units::quantity<detect_bottom_logic_after_hold_timeout_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity detect_bottom_logic_after_hold_timeout_with_units() const
    { return Quantity(detect_bottom_logic_after_hold_timeout() * detect_bottom_logic_after_hold_timeout_unit()); };
  
  boost::units::quantity< detect_bottom_logic_after_hold_timeout_unit,double > detect_bottom_logic_after_hold_timeout_with_units() const
    { return detect_bottom_logic_after_hold_timeout_with_units<boost::units::quantity< detect_bottom_logic_after_hold_timeout_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::length_base_dimension,1 >::type dive_depth_eps_dimension;
  
  typedef boost::units::unit<dive_depth_eps_dimension,boost::units::si::system> dive_depth_eps_unit;
  
  template<typename Quantity >
    void set_dive_depth_eps_with_units(Quantity value_w_units)
    { set_dive_depth_eps(boost::units::quantity<dive_depth_eps_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity dive_depth_eps_with_units() const
    { return Quantity(dive_depth_eps() * dive_depth_eps_unit()); };
  
  boost::units::quantity< dive_depth_eps_unit,double > dive_depth_eps_with_units() const
    { return dive_depth_eps_with_units<boost::units::quantity< dive_depth_eps_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type bottoming_timeout_dimension;
  
  typedef boost::units::unit<bottoming_timeout_dimension,boost::units::si::system> bottoming_timeout_unit;
  
  template<typename Quantity >
    void set_bottoming_timeout_with_units(Quantity value_w_units)
    { set_bottoming_timeout(boost::units::quantity<bottoming_timeout_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity bottoming_timeout_with_units() const
    { return Quantity(bottoming_timeout() * bottoming_timeout_unit()); };
  
  boost::units::quantity< bottoming_timeout_unit,double > bottoming_timeout_with_units() const
    { return bottoming_timeout_with_units<boost::units::quantity< bottoming_timeout_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::length_base_dimension,1 >::type dive_surface_eps_dimension;
  
  typedef boost::units::unit<dive_surface_eps_dimension,boost::units::si::system> dive_surface_eps_unit;
  
  template<typename Quantity >
    void set_dive_surface_eps_with_units(Quantity value_w_units)
    { set_dive_surface_eps(boost::units::quantity<dive_surface_eps_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity dive_surface_eps_with_units() const
    { return Quantity(dive_surface_eps() * dive_surface_eps_unit()); };
  
  boost::units::quantity< dive_surface_eps_unit,double > dive_surface_eps_with_units() const
    { return dive_surface_eps_with_units<boost::units::quantity< dive_surface_eps_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type bot_not_rising_timeout_dimension;
  
  typedef boost::units::unit<bot_not_rising_timeout_dimension,boost::units::si::system> bot_not_rising_timeout_unit;
  
  template<typename Quantity >
    void set_bot_not_rising_timeout_with_units(Quantity value_w_units)
    { set_bot_not_rising_timeout(boost::units::quantity<bot_not_rising_timeout_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity bot_not_rising_timeout_with_units() const
    { return Quantity(bot_not_rising_timeout() * bot_not_rising_timeout_unit()); };
  
  boost::units::quantity< bot_not_rising_timeout_unit,double > bot_not_rising_timeout_with_units() const
    { return bot_not_rising_timeout_with_units<boost::units::quantity< bot_not_rising_timeout_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type motor_on_time_increment_dimension;
  
  typedef boost::units::unit<motor_on_time_increment_dimension,boost::units::si::system> motor_on_time_increment_unit;
  
  template<typename Quantity >
    void set_motor_on_time_increment_with_units(Quantity value_w_units)
    { set_motor_on_time_increment(boost::units::quantity<motor_on_time_increment_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity motor_on_time_increment_with_units() const
    { return Quantity(motor_on_time_increment() * motor_on_time_increment_unit()); };
  
  boost::units::quantity< motor_on_time_increment_unit,google::protobuf::int32 > motor_on_time_increment_with_units() const
    { return motor_on_time_increment_with_units<boost::units::quantity< motor_on_time_increment_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type motor_on_time_max_dimension;
  
  typedef boost::units::unit<motor_on_time_max_dimension,boost::units::si::system> motor_on_time_max_unit;
  
  template<typename Quantity >
    void set_motor_on_time_max_with_units(Quantity value_w_units)
    { set_motor_on_time_max(boost::units::quantity<motor_on_time_max_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity motor_on_time_max_with_units() const
    { return Quantity(motor_on_time_max() * motor_on_time_max_unit()); };
  
  boost::units::quantity< motor_on_time_max_unit,google::protobuf::int32 > motor_on_time_max_with_units() const
    { return motor_on_time_max_with_units<boost::units::quantity< motor_on_time_max_unit,google::protobuf::int32 > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type pitch_angle_min_check_time_dimension;
  
  typedef boost::units::unit<pitch_angle_min_check_time_dimension,boost::units::si::system> pitch_angle_min_check_time_unit;
  
  template<typename Quantity >
    void set_pitch_angle_min_check_time_with_units(Quantity value_w_units)
    { set_pitch_angle_min_check_time(boost::units::quantity<pitch_angle_min_check_time_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity pitch_angle_min_check_time_with_units() const
    { return Quantity(pitch_angle_min_check_time() * pitch_angle_min_check_time_unit()); };
  
  boost::units::quantity< pitch_angle_min_check_time_unit,double > pitch_angle_min_check_time_with_units() const
    { return pitch_angle_min_check_time_with_units<boost::units::quantity< pitch_angle_min_check_time_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::length_base_dimension,1 >::type dive_eps_to_determine_diving_dimension;
  
  typedef boost::units::unit<dive_eps_to_determine_diving_dimension,boost::units::si::system> dive_eps_to_determine_diving_unit;
  
  template<typename Quantity >
    void set_dive_eps_to_determine_diving_with_units(Quantity value_w_units)
    { set_dive_eps_to_determine_diving(boost::units::quantity<dive_eps_to_determine_diving_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity dive_eps_to_determine_diving_with_units() const
    { return Quantity(dive_eps_to_determine_diving() * dive_eps_to_determine_diving_unit()); };
  
  boost::units::quantity< dive_eps_to_determine_diving_unit,double > dive_eps_to_determine_diving_with_units() const
    { return dive_eps_to_determine_diving_with_units<boost::units::quantity< dive_eps_to_determine_diving_unit,double > >(); };
  
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type failed_startup_log_timeout_dimension;
  
  typedef boost::units::unit<failed_startup_log_timeout_dimension,boost::units::si::system> failed_startup_log_timeout_unit;
  
  template<typename Quantity >
    void set_failed_startup_log_timeout_with_units(Quantity value_w_units)
    { set_failed_startup_log_timeout(boost::units::quantity<failed_startup_log_timeout_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity failed_startup_log_timeout_with_units() const
    { return Quantity(failed_startup_log_timeout() * failed_startup_log_timeout_unit()); };
  
  boost::units::quantity< failed_startup_log_timeout_unit,google::protobuf::int32 > failed_startup_log_timeout_with_units() const
    { return failed_startup_log_timeout_with_units<boost::units::quantity< failed_startup_log_timeout_unit,google::protobuf::int32 > >(); };
  
  // @@protoc_insertion_point(class_scope:jaiabot.config.MissionManager)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> include_goal_timeout_states_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> test_mode_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> ignore_error_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_preoffload_script_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_postoffload_script_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_dir_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_log_staging_dir_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_staging_dir_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_log_archive_dir_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_archive_dir_;
    ::goby::middleware::protobuf::AppConfig* app_;
    ::goby::zeromq::protobuf::InterProcessPortalConfig* interprocess_;
    ::goby::middleware::protobuf::TransporterConfig* command_sub_cfg_;
    ::goby::middleware::protobuf::TransporterConfig* contact_update_sub_cfg_;
    ::jaiabot::config::MissionManager_ResolveNoForwardProgress* resolve_no_forward_progress_;
    ::jaiabot::protobuf::CameraCommand* start_camera_command_;
    ::jaiabot::protobuf::CameraCommand* stop_camera_command_;
    int32_t fleet_id_;
    int32_t bot_id_;
    bool use_goal_timeout_;
    bool skip_goal_task_;
    bool is_sim_;
    uint32_t subnet_mask_;
    double startup_timeout_;
    int32_t powered_ascent_motor_on_timeout_;
    int32_t powered_ascent_motor_off_timeout_;
    int32_t dive_prep_timeout_;
    int32_t powered_descent_timeout_;
    double detect_bottom_logic_init_timeout_;
    double detect_bottom_logic_after_hold_timeout_;
    double dive_depth_eps_;
    double bottoming_timeout_;
    double dive_surface_eps_;
    uint32_t total_gps_fix_checks_;
    uint32_t total_gps_degraded_fix_checks_;
    double gps_hdop_fix_;
    double gps_pdop_fix_;
    double gps_after_dive_hdop_fix_;
    double gps_after_dive_pdop_fix_;
    double min_depth_safety_;
    uint32_t total_after_dive_gps_fix_checks_;
    uint32_t goal_timeout_reacquire_gps_attempts_;
    double goal_timeout_buffer_factor_;
    uint32_t tpv_history_max_;
    int rc_setpoint_end_;
    double bot_not_rising_timeout_;
    uint32_t imu_restart_seconds_;
    int32_t motor_on_time_increment_;
    double powered_ascent_throttle_;
    double powered_ascent_throttle_increment_;
    double powered_ascent_throttle_max_;
    int32_t motor_on_time_max_;
    int32_t pitch_angle_checks_;
    double pitch_to_determine_powered_ascent_vertical_;
    double pitch_to_determine_dive_prep_vertical_;
    double pitch_angle_min_check_time_;
    double dive_eps_to_determine_diving_;
    int data_offload_exclude_;
    int32_t failed_startup_log_timeout_;
    double hard_bottom_type_acceleration_;
    int32_t waypoint_with_no_task_slip_radius_;
    int32_t waypoint_with_task_slip_radius_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_bin_2fmission_5fmanager_2fconfig_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// MissionManager_ResolveNoForwardProgress
 
// optional int32 resume_timeout = 1 [default = 10, (.dccl.field) = {
inline bool MissionManager_ResolveNoForwardProgress::_internal_has_resume_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MissionManager_ResolveNoForwardProgress::has_resume_timeout() const {
  return _internal_has_resume_timeout();
}
inline void MissionManager_ResolveNoForwardProgress::clear_resume_timeout() {
  _impl_.resume_timeout_ = 10;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t MissionManager_ResolveNoForwardProgress::_internal_resume_timeout() const {
  return _impl_.resume_timeout_;
}
inline int32_t MissionManager_ResolveNoForwardProgress::resume_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.ResolveNoForwardProgress.resume_timeout)
  return _internal_resume_timeout();
}
inline void MissionManager_ResolveNoForwardProgress::_internal_set_resume_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.resume_timeout_ = value;
}
inline void MissionManager_ResolveNoForwardProgress::set_resume_timeout(int32_t value) {
  _internal_set_resume_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.ResolveNoForwardProgress.resume_timeout)
}
 
// optional int32 pitch_threshold = 2 [default = 30, (.dccl.field) = {
inline bool MissionManager_ResolveNoForwardProgress::_internal_has_pitch_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MissionManager_ResolveNoForwardProgress::has_pitch_threshold() const {
  return _internal_has_pitch_threshold();
}
inline void MissionManager_ResolveNoForwardProgress::clear_pitch_threshold() {
  _impl_.pitch_threshold_ = 30;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t MissionManager_ResolveNoForwardProgress::_internal_pitch_threshold() const {
  return _impl_.pitch_threshold_;
}
inline int32_t MissionManager_ResolveNoForwardProgress::pitch_threshold() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.ResolveNoForwardProgress.pitch_threshold)
  return _internal_pitch_threshold();
}
inline void MissionManager_ResolveNoForwardProgress::_internal_set_pitch_threshold(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.pitch_threshold_ = value;
}
inline void MissionManager_ResolveNoForwardProgress::set_pitch_threshold(int32_t value) {
  _internal_set_pitch_threshold(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.ResolveNoForwardProgress.pitch_threshold)
}
 
// optional int32 desired_speed_threshold = 3 [default = 0, (.dccl.field) = {
inline bool MissionManager_ResolveNoForwardProgress::_internal_has_desired_speed_threshold() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MissionManager_ResolveNoForwardProgress::has_desired_speed_threshold() const {
  return _internal_has_desired_speed_threshold();
}
inline void MissionManager_ResolveNoForwardProgress::clear_desired_speed_threshold() {
  _impl_.desired_speed_threshold_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t MissionManager_ResolveNoForwardProgress::_internal_desired_speed_threshold() const {
  return _impl_.desired_speed_threshold_;
}
inline int32_t MissionManager_ResolveNoForwardProgress::desired_speed_threshold() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.ResolveNoForwardProgress.desired_speed_threshold)
  return _internal_desired_speed_threshold();
}
inline void MissionManager_ResolveNoForwardProgress::_internal_set_desired_speed_threshold(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.desired_speed_threshold_ = value;
}
inline void MissionManager_ResolveNoForwardProgress::set_desired_speed_threshold(int32_t value) {
  _internal_set_desired_speed_threshold(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.ResolveNoForwardProgress.desired_speed_threshold)
}
 
// optional int32 trigger_timeout = 4 [default = 15, (.dccl.field) = {
inline bool MissionManager_ResolveNoForwardProgress::_internal_has_trigger_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MissionManager_ResolveNoForwardProgress::has_trigger_timeout() const {
  return _internal_has_trigger_timeout();
}
inline void MissionManager_ResolveNoForwardProgress::clear_trigger_timeout() {
  _impl_.trigger_timeout_ = 15;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t MissionManager_ResolveNoForwardProgress::_internal_trigger_timeout() const {
  return _impl_.trigger_timeout_;
}
inline int32_t MissionManager_ResolveNoForwardProgress::trigger_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.ResolveNoForwardProgress.trigger_timeout)
  return _internal_trigger_timeout();
}
inline void MissionManager_ResolveNoForwardProgress::_internal_set_trigger_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.trigger_timeout_ = value;
}
inline void MissionManager_ResolveNoForwardProgress::set_trigger_timeout(int32_t value) {
  _internal_set_trigger_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.ResolveNoForwardProgress.trigger_timeout)
}
 
// -------------------------------------------------------------------
 
// MissionManager
 
// optional .goby.middleware.protobuf.AppConfig app = 1;
inline bool MissionManager::_internal_has_app() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.app_ != nullptr);
  return value;
}
inline bool MissionManager::has_app() const {
  return _internal_has_app();
}
inline const ::goby::middleware::protobuf::AppConfig& MissionManager::_internal_app() const {
  const ::goby::middleware::protobuf::AppConfig* p = _impl_.app_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::AppConfig&>(
      ::goby::middleware::protobuf::_AppConfig_default_instance_);
}
inline const ::goby::middleware::protobuf::AppConfig& MissionManager::app() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.app)
  return _internal_app();
}
inline void MissionManager::unsafe_arena_set_allocated_app(
    ::goby::middleware::protobuf::AppConfig* app) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.app_);
  }
  _impl_.app_ = app;
  if (app) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.app)
}
inline ::goby::middleware::protobuf::AppConfig* MissionManager::release_app() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::middleware::protobuf::AppConfig* temp = _impl_.app_;
  _impl_.app_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::protobuf::AppConfig* MissionManager::unsafe_arena_release_app() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.app)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::middleware::protobuf::AppConfig* temp = _impl_.app_;
  _impl_.app_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::AppConfig* MissionManager::_internal_mutable_app() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.app_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::AppConfig>(GetArenaForAllocation());
    _impl_.app_ = p;
  }
  return _impl_.app_;
}
inline ::goby::middleware::protobuf::AppConfig* MissionManager::mutable_app() {
  ::goby::middleware::protobuf::AppConfig* _msg = _internal_mutable_app();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.app)
  return _msg;
}
inline void MissionManager::set_allocated_app(::goby::middleware::protobuf::AppConfig* app) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.app_);
  }
  if (app) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(app));
    if (message_arena != submessage_arena) {
      app = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, app, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.app_ = app;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.app)
}
 
// optional .goby.zeromq.protobuf.InterProcessPortalConfig interprocess = 2;
inline bool MissionManager::_internal_has_interprocess() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.interprocess_ != nullptr);
  return value;
}
inline bool MissionManager::has_interprocess() const {
  return _internal_has_interprocess();
}
inline const ::goby::zeromq::protobuf::InterProcessPortalConfig& MissionManager::_internal_interprocess() const {
  const ::goby::zeromq::protobuf::InterProcessPortalConfig* p = _impl_.interprocess_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::zeromq::protobuf::InterProcessPortalConfig&>(
      ::goby::zeromq::protobuf::_InterProcessPortalConfig_default_instance_);
}
inline const ::goby::zeromq::protobuf::InterProcessPortalConfig& MissionManager::interprocess() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.interprocess)
  return _internal_interprocess();
}
inline void MissionManager::unsafe_arena_set_allocated_interprocess(
    ::goby::zeromq::protobuf::InterProcessPortalConfig* interprocess) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interprocess_);
  }
  _impl_.interprocess_ = interprocess;
  if (interprocess) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.interprocess)
}
inline ::goby::zeromq::protobuf::InterProcessPortalConfig* MissionManager::release_interprocess() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::zeromq::protobuf::InterProcessPortalConfig* temp = _impl_.interprocess_;
  _impl_.interprocess_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::zeromq::protobuf::InterProcessPortalConfig* MissionManager::unsafe_arena_release_interprocess() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.interprocess)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::zeromq::protobuf::InterProcessPortalConfig* temp = _impl_.interprocess_;
  _impl_.interprocess_ = nullptr;
  return temp;
}
inline ::goby::zeromq::protobuf::InterProcessPortalConfig* MissionManager::_internal_mutable_interprocess() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.interprocess_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::zeromq::protobuf::InterProcessPortalConfig>(GetArenaForAllocation());
    _impl_.interprocess_ = p;
  }
  return _impl_.interprocess_;
}
inline ::goby::zeromq::protobuf::InterProcessPortalConfig* MissionManager::mutable_interprocess() {
  ::goby::zeromq::protobuf::InterProcessPortalConfig* _msg = _internal_mutable_interprocess();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.interprocess)
  return _msg;
}
inline void MissionManager::set_allocated_interprocess(::goby::zeromq::protobuf::InterProcessPortalConfig* interprocess) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interprocess_);
  }
  if (interprocess) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interprocess));
    if (message_arena != submessage_arena) {
      interprocess = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interprocess, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.interprocess_ = interprocess;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.interprocess)
}
 
// required int32 fleet_id = 9;
inline bool MissionManager::_internal_has_fleet_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool MissionManager::has_fleet_id() const {
  return _internal_has_fleet_id();
}
inline void MissionManager::clear_fleet_id() {
  _impl_.fleet_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t MissionManager::_internal_fleet_id() const {
  return _impl_.fleet_id_;
}
inline int32_t MissionManager::fleet_id() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.fleet_id)
  return _internal_fleet_id();
}
inline void MissionManager::_internal_set_fleet_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.fleet_id_ = value;
}
inline void MissionManager::set_fleet_id(int32_t value) {
  _internal_set_fleet_id(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.fleet_id)
}
 
// required int32 bot_id = 10;
inline bool MissionManager::_internal_has_bot_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool MissionManager::has_bot_id() const {
  return _internal_has_bot_id();
}
inline void MissionManager::clear_bot_id() {
  _impl_.bot_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t MissionManager::_internal_bot_id() const {
  return _impl_.bot_id_;
}
inline int32_t MissionManager::bot_id() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.bot_id)
  return _internal_bot_id();
}
inline void MissionManager::_internal_set_bot_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.bot_id_ = value;
}
inline void MissionManager::set_bot_id(int32_t value) {
  _internal_set_bot_id(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.bot_id)
}
 
// required .goby.middleware.protobuf.TransporterConfig command_sub_cfg = 11;
inline bool MissionManager::_internal_has_command_sub_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.command_sub_cfg_ != nullptr);
  return value;
}
inline bool MissionManager::has_command_sub_cfg() const {
  return _internal_has_command_sub_cfg();
}
inline const ::goby::middleware::protobuf::TransporterConfig& MissionManager::_internal_command_sub_cfg() const {
  const ::goby::middleware::protobuf::TransporterConfig* p = _impl_.command_sub_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TransporterConfig&>(
      ::goby::middleware::protobuf::_TransporterConfig_default_instance_);
}
inline const ::goby::middleware::protobuf::TransporterConfig& MissionManager::command_sub_cfg() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.command_sub_cfg)
  return _internal_command_sub_cfg();
}
inline void MissionManager::unsafe_arena_set_allocated_command_sub_cfg(
    ::goby::middleware::protobuf::TransporterConfig* command_sub_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.command_sub_cfg_);
  }
  _impl_.command_sub_cfg_ = command_sub_cfg;
  if (command_sub_cfg) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.command_sub_cfg)
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::release_command_sub_cfg() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::goby::middleware::protobuf::TransporterConfig* temp = _impl_.command_sub_cfg_;
  _impl_.command_sub_cfg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::unsafe_arena_release_command_sub_cfg() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.command_sub_cfg)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::goby::middleware::protobuf::TransporterConfig* temp = _impl_.command_sub_cfg_;
  _impl_.command_sub_cfg_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::_internal_mutable_command_sub_cfg() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.command_sub_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TransporterConfig>(GetArenaForAllocation());
    _impl_.command_sub_cfg_ = p;
  }
  return _impl_.command_sub_cfg_;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::mutable_command_sub_cfg() {
  ::goby::middleware::protobuf::TransporterConfig* _msg = _internal_mutable_command_sub_cfg();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.command_sub_cfg)
  return _msg;
}
inline void MissionManager::set_allocated_command_sub_cfg(::goby::middleware::protobuf::TransporterConfig* command_sub_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.command_sub_cfg_);
  }
  if (command_sub_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(command_sub_cfg));
    if (message_arena != submessage_arena) {
      command_sub_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, command_sub_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.command_sub_cfg_ = command_sub_cfg;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.command_sub_cfg)
}
 
// optional .goby.middleware.protobuf.TransporterConfig contact_update_sub_cfg = 13;
inline bool MissionManager::_internal_has_contact_update_sub_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contact_update_sub_cfg_ != nullptr);
  return value;
}
inline bool MissionManager::has_contact_update_sub_cfg() const {
  return _internal_has_contact_update_sub_cfg();
}
inline const ::goby::middleware::protobuf::TransporterConfig& MissionManager::_internal_contact_update_sub_cfg() const {
  const ::goby::middleware::protobuf::TransporterConfig* p = _impl_.contact_update_sub_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TransporterConfig&>(
      ::goby::middleware::protobuf::_TransporterConfig_default_instance_);
}
inline const ::goby::middleware::protobuf::TransporterConfig& MissionManager::contact_update_sub_cfg() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.contact_update_sub_cfg)
  return _internal_contact_update_sub_cfg();
}
inline void MissionManager::unsafe_arena_set_allocated_contact_update_sub_cfg(
    ::goby::middleware::protobuf::TransporterConfig* contact_update_sub_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contact_update_sub_cfg_);
  }
  _impl_.contact_update_sub_cfg_ = contact_update_sub_cfg;
  if (contact_update_sub_cfg) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.contact_update_sub_cfg)
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::release_contact_update_sub_cfg() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::goby::middleware::protobuf::TransporterConfig* temp = _impl_.contact_update_sub_cfg_;
  _impl_.contact_update_sub_cfg_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::unsafe_arena_release_contact_update_sub_cfg() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.contact_update_sub_cfg)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::goby::middleware::protobuf::TransporterConfig* temp = _impl_.contact_update_sub_cfg_;
  _impl_.contact_update_sub_cfg_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::_internal_mutable_contact_update_sub_cfg() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.contact_update_sub_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TransporterConfig>(GetArenaForAllocation());
    _impl_.contact_update_sub_cfg_ = p;
  }
  return _impl_.contact_update_sub_cfg_;
}
inline ::goby::middleware::protobuf::TransporterConfig* MissionManager::mutable_contact_update_sub_cfg() {
  ::goby::middleware::protobuf::TransporterConfig* _msg = _internal_mutable_contact_update_sub_cfg();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.contact_update_sub_cfg)
  return _msg;
}
inline void MissionManager::set_allocated_contact_update_sub_cfg(::goby::middleware::protobuf::TransporterConfig* contact_update_sub_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contact_update_sub_cfg_);
  }
  if (contact_update_sub_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(contact_update_sub_cfg));
    if (message_arena != submessage_arena) {
      contact_update_sub_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contact_update_sub_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.contact_update_sub_cfg_ = contact_update_sub_cfg;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.contact_update_sub_cfg)
}
 
// optional double startup_timeout = 12 [default = 120, (.dccl.field) = {
inline bool MissionManager::_internal_has_startup_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool MissionManager::has_startup_timeout() const {
  return _internal_has_startup_timeout();
}
inline void MissionManager::clear_startup_timeout() {
  _impl_.startup_timeout_ = 120;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline double MissionManager::_internal_startup_timeout() const {
  return _impl_.startup_timeout_;
}
inline double MissionManager::startup_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.startup_timeout)
  return _internal_startup_timeout();
}
inline void MissionManager::_internal_set_startup_timeout(double value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.startup_timeout_ = value;
}
inline void MissionManager::set_startup_timeout(double value) {
  _internal_set_startup_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.startup_timeout)
}
 
// optional int32 powered_ascent_motor_on_timeout = 25 [default = 5, (.dccl.field) = {
inline bool MissionManager::_internal_has_powered_ascent_motor_on_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool MissionManager::has_powered_ascent_motor_on_timeout() const {
  return _internal_has_powered_ascent_motor_on_timeout();
}
inline void MissionManager::clear_powered_ascent_motor_on_timeout() {
  _impl_.powered_ascent_motor_on_timeout_ = 5;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int32_t MissionManager::_internal_powered_ascent_motor_on_timeout() const {
  return _impl_.powered_ascent_motor_on_timeout_;
}
inline int32_t MissionManager::powered_ascent_motor_on_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_ascent_motor_on_timeout)
  return _internal_powered_ascent_motor_on_timeout();
}
inline void MissionManager::_internal_set_powered_ascent_motor_on_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.powered_ascent_motor_on_timeout_ = value;
}
inline void MissionManager::set_powered_ascent_motor_on_timeout(int32_t value) {
  _internal_set_powered_ascent_motor_on_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_ascent_motor_on_timeout)
}
 
// optional int32 powered_ascent_motor_off_timeout = 26 [default = 2, (.dccl.field) = {
inline bool MissionManager::_internal_has_powered_ascent_motor_off_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool MissionManager::has_powered_ascent_motor_off_timeout() const {
  return _internal_has_powered_ascent_motor_off_timeout();
}
inline void MissionManager::clear_powered_ascent_motor_off_timeout() {
  _impl_.powered_ascent_motor_off_timeout_ = 2;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t MissionManager::_internal_powered_ascent_motor_off_timeout() const {
  return _impl_.powered_ascent_motor_off_timeout_;
}
inline int32_t MissionManager::powered_ascent_motor_off_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_ascent_motor_off_timeout)
  return _internal_powered_ascent_motor_off_timeout();
}
inline void MissionManager::_internal_set_powered_ascent_motor_off_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.powered_ascent_motor_off_timeout_ = value;
}
inline void MissionManager::set_powered_ascent_motor_off_timeout(int32_t value) {
  _internal_set_powered_ascent_motor_off_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_ascent_motor_off_timeout)
}
 
// optional int32 dive_prep_timeout = 27 [default = 10, (.dccl.field) = {
inline bool MissionManager::_internal_has_dive_prep_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool MissionManager::has_dive_prep_timeout() const {
  return _internal_has_dive_prep_timeout();
}
inline void MissionManager::clear_dive_prep_timeout() {
  _impl_.dive_prep_timeout_ = 10;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline int32_t MissionManager::_internal_dive_prep_timeout() const {
  return _impl_.dive_prep_timeout_;
}
inline int32_t MissionManager::dive_prep_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.dive_prep_timeout)
  return _internal_dive_prep_timeout();
}
inline void MissionManager::_internal_set_dive_prep_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.dive_prep_timeout_ = value;
}
inline void MissionManager::set_dive_prep_timeout(int32_t value) {
  _internal_set_dive_prep_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.dive_prep_timeout)
}
 
// optional int32 powered_descent_timeout = 28 [default = 100, (.dccl.field) = {
inline bool MissionManager::_internal_has_powered_descent_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool MissionManager::has_powered_descent_timeout() const {
  return _internal_has_powered_descent_timeout();
}
inline void MissionManager::clear_powered_descent_timeout() {
  _impl_.powered_descent_timeout_ = 100;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline int32_t MissionManager::_internal_powered_descent_timeout() const {
  return _impl_.powered_descent_timeout_;
}
inline int32_t MissionManager::powered_descent_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_descent_timeout)
  return _internal_powered_descent_timeout();
}
inline void MissionManager::_internal_set_powered_descent_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.powered_descent_timeout_ = value;
}
inline void MissionManager::set_powered_descent_timeout(int32_t value) {
  _internal_set_powered_descent_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_descent_timeout)
}
 
// optional double detect_bottom_logic_init_timeout = 29 [default = 15, (.dccl.field) = {
inline bool MissionManager::_internal_has_detect_bottom_logic_init_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool MissionManager::has_detect_bottom_logic_init_timeout() const {
  return _internal_has_detect_bottom_logic_init_timeout();
}
inline void MissionManager::clear_detect_bottom_logic_init_timeout() {
  _impl_.detect_bottom_logic_init_timeout_ = 15;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline double MissionManager::_internal_detect_bottom_logic_init_timeout() const {
  return _impl_.detect_bottom_logic_init_timeout_;
}
inline double MissionManager::detect_bottom_logic_init_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.detect_bottom_logic_init_timeout)
  return _internal_detect_bottom_logic_init_timeout();
}
inline void MissionManager::_internal_set_detect_bottom_logic_init_timeout(double value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.detect_bottom_logic_init_timeout_ = value;
}
inline void MissionManager::set_detect_bottom_logic_init_timeout(double value) {
  _internal_set_detect_bottom_logic_init_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.detect_bottom_logic_init_timeout)
}
 
// optional double detect_bottom_logic_after_hold_timeout = 30 [default = 5, (.dccl.field) = {
inline bool MissionManager::_internal_has_detect_bottom_logic_after_hold_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool MissionManager::has_detect_bottom_logic_after_hold_timeout() const {
  return _internal_has_detect_bottom_logic_after_hold_timeout();
}
inline void MissionManager::clear_detect_bottom_logic_after_hold_timeout() {
  _impl_.detect_bottom_logic_after_hold_timeout_ = 5;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline double MissionManager::_internal_detect_bottom_logic_after_hold_timeout() const {
  return _impl_.detect_bottom_logic_after_hold_timeout_;
}
inline double MissionManager::detect_bottom_logic_after_hold_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.detect_bottom_logic_after_hold_timeout)
  return _internal_detect_bottom_logic_after_hold_timeout();
}
inline void MissionManager::_internal_set_detect_bottom_logic_after_hold_timeout(double value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.detect_bottom_logic_after_hold_timeout_ = value;
}
inline void MissionManager::set_detect_bottom_logic_after_hold_timeout(double value) {
  _internal_set_detect_bottom_logic_after_hold_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.detect_bottom_logic_after_hold_timeout)
}
 
// optional double dive_depth_eps = 31 [default = 0.1, (.dccl.field) = {
inline bool MissionManager::_internal_has_dive_depth_eps() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool MissionManager::has_dive_depth_eps() const {
  return _internal_has_dive_depth_eps();
}
inline void MissionManager::clear_dive_depth_eps() {
  _impl_.dive_depth_eps_ = 0.1;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline double MissionManager::_internal_dive_depth_eps() const {
  return _impl_.dive_depth_eps_;
}
inline double MissionManager::dive_depth_eps() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.dive_depth_eps)
  return _internal_dive_depth_eps();
}
inline void MissionManager::_internal_set_dive_depth_eps(double value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.dive_depth_eps_ = value;
}
inline void MissionManager::set_dive_depth_eps(double value) {
  _internal_set_dive_depth_eps(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.dive_depth_eps)
}
 
// optional double bottoming_timeout = 32 [default = 3, (.dccl.field) = {
inline bool MissionManager::_internal_has_bottoming_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool MissionManager::has_bottoming_timeout() const {
  return _internal_has_bottoming_timeout();
}
inline void MissionManager::clear_bottoming_timeout() {
  _impl_.bottoming_timeout_ = 3;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline double MissionManager::_internal_bottoming_timeout() const {
  return _impl_.bottoming_timeout_;
}
inline double MissionManager::bottoming_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.bottoming_timeout)
  return _internal_bottoming_timeout();
}
inline void MissionManager::_internal_set_bottoming_timeout(double value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.bottoming_timeout_ = value;
}
inline void MissionManager::set_bottoming_timeout(double value) {
  _internal_set_bottoming_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.bottoming_timeout)
}
 
// optional double dive_surface_eps = 33 [default = 0.75, (.dccl.field) = {
inline bool MissionManager::_internal_has_dive_surface_eps() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool MissionManager::has_dive_surface_eps() const {
  return _internal_has_dive_surface_eps();
}
inline void MissionManager::clear_dive_surface_eps() {
  _impl_.dive_surface_eps_ = 0.75;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline double MissionManager::_internal_dive_surface_eps() const {
  return _impl_.dive_surface_eps_;
}
inline double MissionManager::dive_surface_eps() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.dive_surface_eps)
  return _internal_dive_surface_eps();
}
inline void MissionManager::_internal_set_dive_surface_eps(double value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.dive_surface_eps_ = value;
}
inline void MissionManager::set_dive_surface_eps(double value) {
  _internal_set_dive_surface_eps(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.dive_surface_eps)
}
 
// optional uint32 total_gps_fix_checks = 34 [default = 10];
inline bool MissionManager::_internal_has_total_gps_fix_checks() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool MissionManager::has_total_gps_fix_checks() const {
  return _internal_has_total_gps_fix_checks();
}
inline void MissionManager::clear_total_gps_fix_checks() {
  _impl_.total_gps_fix_checks_ = 10u;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline uint32_t MissionManager::_internal_total_gps_fix_checks() const {
  return _impl_.total_gps_fix_checks_;
}
inline uint32_t MissionManager::total_gps_fix_checks() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.total_gps_fix_checks)
  return _internal_total_gps_fix_checks();
}
inline void MissionManager::_internal_set_total_gps_fix_checks(uint32_t value) {
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.total_gps_fix_checks_ = value;
}
inline void MissionManager::set_total_gps_fix_checks(uint32_t value) {
  _internal_set_total_gps_fix_checks(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.total_gps_fix_checks)
}
 
// optional uint32 total_gps_degraded_fix_checks = 35 [default = 2];
inline bool MissionManager::_internal_has_total_gps_degraded_fix_checks() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool MissionManager::has_total_gps_degraded_fix_checks() const {
  return _internal_has_total_gps_degraded_fix_checks();
}
inline void MissionManager::clear_total_gps_degraded_fix_checks() {
  _impl_.total_gps_degraded_fix_checks_ = 2u;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline uint32_t MissionManager::_internal_total_gps_degraded_fix_checks() const {
  return _impl_.total_gps_degraded_fix_checks_;
}
inline uint32_t MissionManager::total_gps_degraded_fix_checks() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.total_gps_degraded_fix_checks)
  return _internal_total_gps_degraded_fix_checks();
}
inline void MissionManager::_internal_set_total_gps_degraded_fix_checks(uint32_t value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.total_gps_degraded_fix_checks_ = value;
}
inline void MissionManager::set_total_gps_degraded_fix_checks(uint32_t value) {
  _internal_set_total_gps_degraded_fix_checks(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.total_gps_degraded_fix_checks)
}
 
// optional double gps_hdop_fix = 36 [default = 1.3];
inline bool MissionManager::_internal_has_gps_hdop_fix() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool MissionManager::has_gps_hdop_fix() const {
  return _internal_has_gps_hdop_fix();
}
inline void MissionManager::clear_gps_hdop_fix() {
  _impl_.gps_hdop_fix_ = 1.3;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline double MissionManager::_internal_gps_hdop_fix() const {
  return _impl_.gps_hdop_fix_;
}
inline double MissionManager::gps_hdop_fix() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.gps_hdop_fix)
  return _internal_gps_hdop_fix();
}
inline void MissionManager::_internal_set_gps_hdop_fix(double value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.gps_hdop_fix_ = value;
}
inline void MissionManager::set_gps_hdop_fix(double value) {
  _internal_set_gps_hdop_fix(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.gps_hdop_fix)
}
 
// optional double gps_pdop_fix = 37 [default = 2.2];
inline bool MissionManager::_internal_has_gps_pdop_fix() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool MissionManager::has_gps_pdop_fix() const {
  return _internal_has_gps_pdop_fix();
}
inline void MissionManager::clear_gps_pdop_fix() {
  _impl_.gps_pdop_fix_ = 2.2;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline double MissionManager::_internal_gps_pdop_fix() const {
  return _impl_.gps_pdop_fix_;
}
inline double MissionManager::gps_pdop_fix() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.gps_pdop_fix)
  return _internal_gps_pdop_fix();
}
inline void MissionManager::_internal_set_gps_pdop_fix(double value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.gps_pdop_fix_ = value;
}
inline void MissionManager::set_gps_pdop_fix(double value) {
  _internal_set_gps_pdop_fix(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.gps_pdop_fix)
}
 
// optional uint32 total_after_dive_gps_fix_checks = 38 [default = 15];
inline bool MissionManager::_internal_has_total_after_dive_gps_fix_checks() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool MissionManager::has_total_after_dive_gps_fix_checks() const {
  return _internal_has_total_after_dive_gps_fix_checks();
}
inline void MissionManager::clear_total_after_dive_gps_fix_checks() {
  _impl_.total_after_dive_gps_fix_checks_ = 15u;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline uint32_t MissionManager::_internal_total_after_dive_gps_fix_checks() const {
  return _impl_.total_after_dive_gps_fix_checks_;
}
inline uint32_t MissionManager::total_after_dive_gps_fix_checks() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.total_after_dive_gps_fix_checks)
  return _internal_total_after_dive_gps_fix_checks();
}
inline void MissionManager::_internal_set_total_after_dive_gps_fix_checks(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000008u;
  _impl_.total_after_dive_gps_fix_checks_ = value;
}
inline void MissionManager::set_total_after_dive_gps_fix_checks(uint32_t value) {
  _internal_set_total_after_dive_gps_fix_checks(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.total_after_dive_gps_fix_checks)
}
 
// optional double gps_after_dive_hdop_fix = 39 [default = 1.3];
inline bool MissionManager::_internal_has_gps_after_dive_hdop_fix() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool MissionManager::has_gps_after_dive_hdop_fix() const {
  return _internal_has_gps_after_dive_hdop_fix();
}
inline void MissionManager::clear_gps_after_dive_hdop_fix() {
  _impl_.gps_after_dive_hdop_fix_ = 1.3;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline double MissionManager::_internal_gps_after_dive_hdop_fix() const {
  return _impl_.gps_after_dive_hdop_fix_;
}
inline double MissionManager::gps_after_dive_hdop_fix() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.gps_after_dive_hdop_fix)
  return _internal_gps_after_dive_hdop_fix();
}
inline void MissionManager::_internal_set_gps_after_dive_hdop_fix(double value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.gps_after_dive_hdop_fix_ = value;
}
inline void MissionManager::set_gps_after_dive_hdop_fix(double value) {
  _internal_set_gps_after_dive_hdop_fix(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.gps_after_dive_hdop_fix)
}
 
// optional double gps_after_dive_pdop_fix = 40 [default = 2.2];
inline bool MissionManager::_internal_has_gps_after_dive_pdop_fix() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool MissionManager::has_gps_after_dive_pdop_fix() const {
  return _internal_has_gps_after_dive_pdop_fix();
}
inline void MissionManager::clear_gps_after_dive_pdop_fix() {
  _impl_.gps_after_dive_pdop_fix_ = 2.2;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline double MissionManager::_internal_gps_after_dive_pdop_fix() const {
  return _impl_.gps_after_dive_pdop_fix_;
}
inline double MissionManager::gps_after_dive_pdop_fix() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.gps_after_dive_pdop_fix)
  return _internal_gps_after_dive_pdop_fix();
}
inline void MissionManager::_internal_set_gps_after_dive_pdop_fix(double value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.gps_after_dive_pdop_fix_ = value;
}
inline void MissionManager::set_gps_after_dive_pdop_fix(double value) {
  _internal_set_gps_after_dive_pdop_fix(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.gps_after_dive_pdop_fix)
}
 
// optional double min_depth_safety = 41 [default = -1];
inline bool MissionManager::_internal_has_min_depth_safety() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool MissionManager::has_min_depth_safety() const {
  return _internal_has_min_depth_safety();
}
inline void MissionManager::clear_min_depth_safety() {
  _impl_.min_depth_safety_ = -1;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline double MissionManager::_internal_min_depth_safety() const {
  return _impl_.min_depth_safety_;
}
inline double MissionManager::min_depth_safety() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.min_depth_safety)
  return _internal_min_depth_safety();
}
inline void MissionManager::_internal_set_min_depth_safety(double value) {
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.min_depth_safety_ = value;
}
inline void MissionManager::set_min_depth_safety(double value) {
  _internal_set_min_depth_safety(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.min_depth_safety)
}
 
// optional double goal_timeout_buffer_factor = 44 [default = 1];
inline bool MissionManager::_internal_has_goal_timeout_buffer_factor() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool MissionManager::has_goal_timeout_buffer_factor() const {
  return _internal_has_goal_timeout_buffer_factor();
}
inline void MissionManager::clear_goal_timeout_buffer_factor() {
  _impl_.goal_timeout_buffer_factor_ = 1;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline double MissionManager::_internal_goal_timeout_buffer_factor() const {
  return _impl_.goal_timeout_buffer_factor_;
}
inline double MissionManager::goal_timeout_buffer_factor() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.goal_timeout_buffer_factor)
  return _internal_goal_timeout_buffer_factor();
}
inline void MissionManager::_internal_set_goal_timeout_buffer_factor(double value) {
  _impl_._has_bits_[1] |= 0x00000020u;
  _impl_.goal_timeout_buffer_factor_ = value;
}
inline void MissionManager::set_goal_timeout_buffer_factor(double value) {
  _internal_set_goal_timeout_buffer_factor(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.goal_timeout_buffer_factor)
}
 
// optional uint32 goal_timeout_reacquire_gps_attempts = 45 [default = 2];
inline bool MissionManager::_internal_has_goal_timeout_reacquire_gps_attempts() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool MissionManager::has_goal_timeout_reacquire_gps_attempts() const {
  return _internal_has_goal_timeout_reacquire_gps_attempts();
}
inline void MissionManager::clear_goal_timeout_reacquire_gps_attempts() {
  _impl_.goal_timeout_reacquire_gps_attempts_ = 2u;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline uint32_t MissionManager::_internal_goal_timeout_reacquire_gps_attempts() const {
  return _impl_.goal_timeout_reacquire_gps_attempts_;
}
inline uint32_t MissionManager::goal_timeout_reacquire_gps_attempts() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.goal_timeout_reacquire_gps_attempts)
  return _internal_goal_timeout_reacquire_gps_attempts();
}
inline void MissionManager::_internal_set_goal_timeout_reacquire_gps_attempts(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000010u;
  _impl_.goal_timeout_reacquire_gps_attempts_ = value;
}
inline void MissionManager::set_goal_timeout_reacquire_gps_attempts(uint32_t value) {
  _internal_set_goal_timeout_reacquire_gps_attempts(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.goal_timeout_reacquire_gps_attempts)
}
 
// optional uint32 tpv_history_max = 46 [default = 15];
inline bool MissionManager::_internal_has_tpv_history_max() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline bool MissionManager::has_tpv_history_max() const {
  return _internal_has_tpv_history_max();
}
inline void MissionManager::clear_tpv_history_max() {
  _impl_.tpv_history_max_ = 15u;
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline uint32_t MissionManager::_internal_tpv_history_max() const {
  return _impl_.tpv_history_max_;
}
inline uint32_t MissionManager::tpv_history_max() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.tpv_history_max)
  return _internal_tpv_history_max();
}
inline void MissionManager::_internal_set_tpv_history_max(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000040u;
  _impl_.tpv_history_max_ = value;
}
inline void MissionManager::set_tpv_history_max(uint32_t value) {
  _internal_set_tpv_history_max(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.tpv_history_max)
}
 
// optional bool use_goal_timeout = 47 [default = false];
inline bool MissionManager::_internal_has_use_goal_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool MissionManager::has_use_goal_timeout() const {
  return _internal_has_use_goal_timeout();
}
inline void MissionManager::clear_use_goal_timeout() {
  _impl_.use_goal_timeout_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool MissionManager::_internal_use_goal_timeout() const {
  return _impl_.use_goal_timeout_;
}
inline bool MissionManager::use_goal_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.use_goal_timeout)
  return _internal_use_goal_timeout();
}
inline void MissionManager::_internal_set_use_goal_timeout(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.use_goal_timeout_ = value;
}
inline void MissionManager::set_use_goal_timeout(bool value) {
  _internal_set_use_goal_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.use_goal_timeout)
}
 
// optional bool skip_goal_task = 48 [default = false];
inline bool MissionManager::_internal_has_skip_goal_task() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool MissionManager::has_skip_goal_task() const {
  return _internal_has_skip_goal_task();
}
inline void MissionManager::clear_skip_goal_task() {
  _impl_.skip_goal_task_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool MissionManager::_internal_skip_goal_task() const {
  return _impl_.skip_goal_task_;
}
inline bool MissionManager::skip_goal_task() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.skip_goal_task)
  return _internal_skip_goal_task();
}
inline void MissionManager::_internal_set_skip_goal_task(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.skip_goal_task_ = value;
}
inline void MissionManager::set_skip_goal_task(bool value) {
  _internal_set_skip_goal_task(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.skip_goal_task)
}
 
// repeated .jaiabot.protobuf.MissionState include_goal_timeout_states = 49;
inline int MissionManager::_internal_include_goal_timeout_states_size() const {
  return _impl_.include_goal_timeout_states_.size();
}
inline int MissionManager::include_goal_timeout_states_size() const {
  return _internal_include_goal_timeout_states_size();
}
inline void MissionManager::clear_include_goal_timeout_states() {
  _impl_.include_goal_timeout_states_.Clear();
}
inline ::jaiabot::protobuf::MissionState MissionManager::_internal_include_goal_timeout_states(int index) const {
  return static_cast< ::jaiabot::protobuf::MissionState >(_impl_.include_goal_timeout_states_.Get(index));
}
inline ::jaiabot::protobuf::MissionState MissionManager::include_goal_timeout_states(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.include_goal_timeout_states)
  return _internal_include_goal_timeout_states(index);
}
inline void MissionManager::set_include_goal_timeout_states(int index, ::jaiabot::protobuf::MissionState value) {
  assert(::jaiabot::protobuf::MissionState_IsValid(value));
  _impl_.include_goal_timeout_states_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.include_goal_timeout_states)
}
inline void MissionManager::_internal_add_include_goal_timeout_states(::jaiabot::protobuf::MissionState value) {
  assert(::jaiabot::protobuf::MissionState_IsValid(value));
  _impl_.include_goal_timeout_states_.Add(value);
}
inline void MissionManager::add_include_goal_timeout_states(::jaiabot::protobuf::MissionState value) {
  _internal_add_include_goal_timeout_states(value);
  // @@protoc_insertion_point(field_add:jaiabot.config.MissionManager.include_goal_timeout_states)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
MissionManager::include_goal_timeout_states() const {
  // @@protoc_insertion_point(field_list:jaiabot.config.MissionManager.include_goal_timeout_states)
  return _impl_.include_goal_timeout_states_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::_internal_mutable_include_goal_timeout_states() {
  return &_impl_.include_goal_timeout_states_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::mutable_include_goal_timeout_states() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.config.MissionManager.include_goal_timeout_states)
  return _internal_mutable_include_goal_timeout_states();
}
 
// optional .jaiabot.config.MissionManager.RemoteControlSetpointEnd rc_setpoint_end = 50 [default = RC_SETPOINT_ENDS_IN_STATIONKEEP];
inline bool MissionManager::_internal_has_rc_setpoint_end() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool MissionManager::has_rc_setpoint_end() const {
  return _internal_has_rc_setpoint_end();
}
inline void MissionManager::clear_rc_setpoint_end() {
  _impl_.rc_setpoint_end_ = 1;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline ::jaiabot::config::MissionManager_RemoteControlSetpointEnd MissionManager::_internal_rc_setpoint_end() const {
  return static_cast< ::jaiabot::config::MissionManager_RemoteControlSetpointEnd >(_impl_.rc_setpoint_end_);
}
inline ::jaiabot::config::MissionManager_RemoteControlSetpointEnd MissionManager::rc_setpoint_end() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.rc_setpoint_end)
  return _internal_rc_setpoint_end();
}
inline void MissionManager::_internal_set_rc_setpoint_end(::jaiabot::config::MissionManager_RemoteControlSetpointEnd value) {
  assert(::jaiabot::config::MissionManager_RemoteControlSetpointEnd_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000080u;
  _impl_.rc_setpoint_end_ = value;
}
inline void MissionManager::set_rc_setpoint_end(::jaiabot::config::MissionManager_RemoteControlSetpointEnd value) {
  _internal_set_rc_setpoint_end(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.rc_setpoint_end)
}
 
// optional uint32 imu_restart_seconds = 51 [default = 15];
inline bool MissionManager::_internal_has_imu_restart_seconds() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline bool MissionManager::has_imu_restart_seconds() const {
  return _internal_has_imu_restart_seconds();
}
inline void MissionManager::clear_imu_restart_seconds() {
  _impl_.imu_restart_seconds_ = 15u;
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline uint32_t MissionManager::_internal_imu_restart_seconds() const {
  return _impl_.imu_restart_seconds_;
}
inline uint32_t MissionManager::imu_restart_seconds() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.imu_restart_seconds)
  return _internal_imu_restart_seconds();
}
inline void MissionManager::_internal_set_imu_restart_seconds(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000200u;
  _impl_.imu_restart_seconds_ = value;
}
inline void MissionManager::set_imu_restart_seconds(uint32_t value) {
  _internal_set_imu_restart_seconds(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.imu_restart_seconds)
}
 
// optional double bot_not_rising_timeout = 52 [default = 6, (.dccl.field) = {
inline bool MissionManager::_internal_has_bot_not_rising_timeout() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool MissionManager::has_bot_not_rising_timeout() const {
  return _internal_has_bot_not_rising_timeout();
}
inline void MissionManager::clear_bot_not_rising_timeout() {
  _impl_.bot_not_rising_timeout_ = 6;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline double MissionManager::_internal_bot_not_rising_timeout() const {
  return _impl_.bot_not_rising_timeout_;
}
inline double MissionManager::bot_not_rising_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.bot_not_rising_timeout)
  return _internal_bot_not_rising_timeout();
}
inline void MissionManager::_internal_set_bot_not_rising_timeout(double value) {
  _impl_._has_bits_[1] |= 0x00000100u;
  _impl_.bot_not_rising_timeout_ = value;
}
inline void MissionManager::set_bot_not_rising_timeout(double value) {
  _internal_set_bot_not_rising_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.bot_not_rising_timeout)
}
 
// optional int32 motor_on_time_increment = 53 [default = 1, (.dccl.field) = {
inline bool MissionManager::_internal_has_motor_on_time_increment() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool MissionManager::has_motor_on_time_increment() const {
  return _internal_has_motor_on_time_increment();
}
inline void MissionManager::clear_motor_on_time_increment() {
  _impl_.motor_on_time_increment_ = 1;
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline int32_t MissionManager::_internal_motor_on_time_increment() const {
  return _impl_.motor_on_time_increment_;
}
inline int32_t MissionManager::motor_on_time_increment() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.motor_on_time_increment)
  return _internal_motor_on_time_increment();
}
inline void MissionManager::_internal_set_motor_on_time_increment(int32_t value) {
  _impl_._has_bits_[1] |= 0x00000400u;
  _impl_.motor_on_time_increment_ = value;
}
inline void MissionManager::set_motor_on_time_increment(int32_t value) {
  _internal_set_motor_on_time_increment(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.motor_on_time_increment)
}
 
// optional int32 motor_on_time_max = 54 [default = 10, (.dccl.field) = {
inline bool MissionManager::_internal_has_motor_on_time_max() const {
  bool value = (_impl_._has_bits_[1] & 0x00004000u) != 0;
  return value;
}
inline bool MissionManager::has_motor_on_time_max() const {
  return _internal_has_motor_on_time_max();
}
inline void MissionManager::clear_motor_on_time_max() {
  _impl_.motor_on_time_max_ = 10;
  _impl_._has_bits_[1] &= ~0x00004000u;
}
inline int32_t MissionManager::_internal_motor_on_time_max() const {
  return _impl_.motor_on_time_max_;
}
inline int32_t MissionManager::motor_on_time_max() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.motor_on_time_max)
  return _internal_motor_on_time_max();
}
inline void MissionManager::_internal_set_motor_on_time_max(int32_t value) {
  _impl_._has_bits_[1] |= 0x00004000u;
  _impl_.motor_on_time_max_ = value;
}
inline void MissionManager::set_motor_on_time_max(int32_t value) {
  _internal_set_motor_on_time_max(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.motor_on_time_max)
}
 
// optional double powered_ascent_throttle = 55 [default = 25];
inline bool MissionManager::_internal_has_powered_ascent_throttle() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline bool MissionManager::has_powered_ascent_throttle() const {
  return _internal_has_powered_ascent_throttle();
}
inline void MissionManager::clear_powered_ascent_throttle() {
  _impl_.powered_ascent_throttle_ = 25;
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline double MissionManager::_internal_powered_ascent_throttle() const {
  return _impl_.powered_ascent_throttle_;
}
inline double MissionManager::powered_ascent_throttle() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_ascent_throttle)
  return _internal_powered_ascent_throttle();
}
inline void MissionManager::_internal_set_powered_ascent_throttle(double value) {
  _impl_._has_bits_[1] |= 0x00000800u;
  _impl_.powered_ascent_throttle_ = value;
}
inline void MissionManager::set_powered_ascent_throttle(double value) {
  _internal_set_powered_ascent_throttle(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_ascent_throttle)
}
 
// optional double powered_ascent_throttle_increment = 56 [default = 5];
inline bool MissionManager::_internal_has_powered_ascent_throttle_increment() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline bool MissionManager::has_powered_ascent_throttle_increment() const {
  return _internal_has_powered_ascent_throttle_increment();
}
inline void MissionManager::clear_powered_ascent_throttle_increment() {
  _impl_.powered_ascent_throttle_increment_ = 5;
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline double MissionManager::_internal_powered_ascent_throttle_increment() const {
  return _impl_.powered_ascent_throttle_increment_;
}
inline double MissionManager::powered_ascent_throttle_increment() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_ascent_throttle_increment)
  return _internal_powered_ascent_throttle_increment();
}
inline void MissionManager::_internal_set_powered_ascent_throttle_increment(double value) {
  _impl_._has_bits_[1] |= 0x00001000u;
  _impl_.powered_ascent_throttle_increment_ = value;
}
inline void MissionManager::set_powered_ascent_throttle_increment(double value) {
  _internal_set_powered_ascent_throttle_increment(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_ascent_throttle_increment)
}
 
// optional double powered_ascent_throttle_max = 57 [default = 60];
inline bool MissionManager::_internal_has_powered_ascent_throttle_max() const {
  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline bool MissionManager::has_powered_ascent_throttle_max() const {
  return _internal_has_powered_ascent_throttle_max();
}
inline void MissionManager::clear_powered_ascent_throttle_max() {
  _impl_.powered_ascent_throttle_max_ = 60;
  _impl_._has_bits_[1] &= ~0x00002000u;
}
inline double MissionManager::_internal_powered_ascent_throttle_max() const {
  return _impl_.powered_ascent_throttle_max_;
}
inline double MissionManager::powered_ascent_throttle_max() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.powered_ascent_throttle_max)
  return _internal_powered_ascent_throttle_max();
}
inline void MissionManager::_internal_set_powered_ascent_throttle_max(double value) {
  _impl_._has_bits_[1] |= 0x00002000u;
  _impl_.powered_ascent_throttle_max_ = value;
}
inline void MissionManager::set_powered_ascent_throttle_max(double value) {
  _internal_set_powered_ascent_throttle_max(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.powered_ascent_throttle_max)
}
 
// optional double pitch_to_determine_powered_ascent_vertical = 58 [default = 30];
inline bool MissionManager::_internal_has_pitch_to_determine_powered_ascent_vertical() const {
  bool value = (_impl_._has_bits_[1] & 0x00010000u) != 0;
  return value;
}
inline bool MissionManager::has_pitch_to_determine_powered_ascent_vertical() const {
  return _internal_has_pitch_to_determine_powered_ascent_vertical();
}
inline void MissionManager::clear_pitch_to_determine_powered_ascent_vertical() {
  _impl_.pitch_to_determine_powered_ascent_vertical_ = 30;
  _impl_._has_bits_[1] &= ~0x00010000u;
}
inline double MissionManager::_internal_pitch_to_determine_powered_ascent_vertical() const {
  return _impl_.pitch_to_determine_powered_ascent_vertical_;
}
inline double MissionManager::pitch_to_determine_powered_ascent_vertical() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.pitch_to_determine_powered_ascent_vertical)
  return _internal_pitch_to_determine_powered_ascent_vertical();
}
inline void MissionManager::_internal_set_pitch_to_determine_powered_ascent_vertical(double value) {
  _impl_._has_bits_[1] |= 0x00010000u;
  _impl_.pitch_to_determine_powered_ascent_vertical_ = value;
}
inline void MissionManager::set_pitch_to_determine_powered_ascent_vertical(double value) {
  _internal_set_pitch_to_determine_powered_ascent_vertical(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.pitch_to_determine_powered_ascent_vertical)
}
 
// optional double pitch_to_determine_dive_prep_vertical = 59 [default = 70];
inline bool MissionManager::_internal_has_pitch_to_determine_dive_prep_vertical() const {
  bool value = (_impl_._has_bits_[1] & 0x00020000u) != 0;
  return value;
}
inline bool MissionManager::has_pitch_to_determine_dive_prep_vertical() const {
  return _internal_has_pitch_to_determine_dive_prep_vertical();
}
inline void MissionManager::clear_pitch_to_determine_dive_prep_vertical() {
  _impl_.pitch_to_determine_dive_prep_vertical_ = 70;
  _impl_._has_bits_[1] &= ~0x00020000u;
}
inline double MissionManager::_internal_pitch_to_determine_dive_prep_vertical() const {
  return _impl_.pitch_to_determine_dive_prep_vertical_;
}
inline double MissionManager::pitch_to_determine_dive_prep_vertical() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.pitch_to_determine_dive_prep_vertical)
  return _internal_pitch_to_determine_dive_prep_vertical();
}
inline void MissionManager::_internal_set_pitch_to_determine_dive_prep_vertical(double value) {
  _impl_._has_bits_[1] |= 0x00020000u;
  _impl_.pitch_to_determine_dive_prep_vertical_ = value;
}
inline void MissionManager::set_pitch_to_determine_dive_prep_vertical(double value) {
  _internal_set_pitch_to_determine_dive_prep_vertical(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.pitch_to_determine_dive_prep_vertical)
}
 
// optional int32 pitch_angle_checks = 60 [default = 3];
inline bool MissionManager::_internal_has_pitch_angle_checks() const {
  bool value = (_impl_._has_bits_[1] & 0x00008000u) != 0;
  return value;
}
inline bool MissionManager::has_pitch_angle_checks() const {
  return _internal_has_pitch_angle_checks();
}
inline void MissionManager::clear_pitch_angle_checks() {
  _impl_.pitch_angle_checks_ = 3;
  _impl_._has_bits_[1] &= ~0x00008000u;
}
inline int32_t MissionManager::_internal_pitch_angle_checks() const {
  return _impl_.pitch_angle_checks_;
}
inline int32_t MissionManager::pitch_angle_checks() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.pitch_angle_checks)
  return _internal_pitch_angle_checks();
}
inline void MissionManager::_internal_set_pitch_angle_checks(int32_t value) {
  _impl_._has_bits_[1] |= 0x00008000u;
  _impl_.pitch_angle_checks_ = value;
}
inline void MissionManager::set_pitch_angle_checks(int32_t value) {
  _internal_set_pitch_angle_checks(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.pitch_angle_checks)
}
 
// optional double pitch_angle_min_check_time = 61 [default = 1, (.dccl.field) = {
inline bool MissionManager::_internal_has_pitch_angle_min_check_time() const {
  bool value = (_impl_._has_bits_[1] & 0x00040000u) != 0;
  return value;
}
inline bool MissionManager::has_pitch_angle_min_check_time() const {
  return _internal_has_pitch_angle_min_check_time();
}
inline void MissionManager::clear_pitch_angle_min_check_time() {
  _impl_.pitch_angle_min_check_time_ = 1;
  _impl_._has_bits_[1] &= ~0x00040000u;
}
inline double MissionManager::_internal_pitch_angle_min_check_time() const {
  return _impl_.pitch_angle_min_check_time_;
}
inline double MissionManager::pitch_angle_min_check_time() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.pitch_angle_min_check_time)
  return _internal_pitch_angle_min_check_time();
}
inline void MissionManager::_internal_set_pitch_angle_min_check_time(double value) {
  _impl_._has_bits_[1] |= 0x00040000u;
  _impl_.pitch_angle_min_check_time_ = value;
}
inline void MissionManager::set_pitch_angle_min_check_time(double value) {
  _internal_set_pitch_angle_min_check_time(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.pitch_angle_min_check_time)
}
 
// optional double dive_eps_to_determine_diving = 62 [default = 0.3, (.dccl.field) = {
inline bool MissionManager::_internal_has_dive_eps_to_determine_diving() const {
  bool value = (_impl_._has_bits_[1] & 0x00080000u) != 0;
  return value;
}
inline bool MissionManager::has_dive_eps_to_determine_diving() const {
  return _internal_has_dive_eps_to_determine_diving();
}
inline void MissionManager::clear_dive_eps_to_determine_diving() {
  _impl_.dive_eps_to_determine_diving_ = 0.3;
  _impl_._has_bits_[1] &= ~0x00080000u;
}
inline double MissionManager::_internal_dive_eps_to_determine_diving() const {
  return _impl_.dive_eps_to_determine_diving_;
}
inline double MissionManager::dive_eps_to_determine_diving() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.dive_eps_to_determine_diving)
  return _internal_dive_eps_to_determine_diving();
}
inline void MissionManager::_internal_set_dive_eps_to_determine_diving(double value) {
  _impl_._has_bits_[1] |= 0x00080000u;
  _impl_.dive_eps_to_determine_diving_ = value;
}
inline void MissionManager::set_dive_eps_to_determine_diving(double value) {
  _internal_set_dive_eps_to_determine_diving(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.dive_eps_to_determine_diving)
}
 
// required string data_preoffload_script = 70;
inline bool MissionManager::_internal_has_data_preoffload_script() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MissionManager::has_data_preoffload_script() const {
  return _internal_has_data_preoffload_script();
}
inline void MissionManager::clear_data_preoffload_script() {
  _impl_.data_preoffload_script_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MissionManager::data_preoffload_script() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.data_preoffload_script)
  return _internal_data_preoffload_script();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MissionManager::set_data_preoffload_script(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_preoffload_script_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.data_preoffload_script)
}
inline std::string* MissionManager::mutable_data_preoffload_script() {
  std::string* _s = _internal_mutable_data_preoffload_script();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.data_preoffload_script)
  return _s;
}
inline const std::string& MissionManager::_internal_data_preoffload_script() const {
  return _impl_.data_preoffload_script_.Get();
}
inline void MissionManager::_internal_set_data_preoffload_script(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_preoffload_script_.Set(value, GetArenaForAllocation());
}
inline std::string* MissionManager::_internal_mutable_data_preoffload_script() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_preoffload_script_.Mutable(GetArenaForAllocation());
}
inline std::string* MissionManager::release_data_preoffload_script() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.data_preoffload_script)
  if (!_internal_has_data_preoffload_script()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_preoffload_script_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_preoffload_script_.IsDefault()) {
    _impl_.data_preoffload_script_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MissionManager::set_allocated_data_preoffload_script(std::string* data_preoffload_script) {
  if (data_preoffload_script != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_preoffload_script_.SetAllocated(data_preoffload_script, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_preoffload_script_.IsDefault()) {
    _impl_.data_preoffload_script_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.data_preoffload_script)
}
 
// required string data_postoffload_script = 71;
inline bool MissionManager::_internal_has_data_postoffload_script() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MissionManager::has_data_postoffload_script() const {
  return _internal_has_data_postoffload_script();
}
inline void MissionManager::clear_data_postoffload_script() {
  _impl_.data_postoffload_script_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MissionManager::data_postoffload_script() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.data_postoffload_script)
  return _internal_data_postoffload_script();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MissionManager::set_data_postoffload_script(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.data_postoffload_script_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.data_postoffload_script)
}
inline std::string* MissionManager::mutable_data_postoffload_script() {
  std::string* _s = _internal_mutable_data_postoffload_script();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.data_postoffload_script)
  return _s;
}
inline const std::string& MissionManager::_internal_data_postoffload_script() const {
  return _impl_.data_postoffload_script_.Get();
}
inline void MissionManager::_internal_set_data_postoffload_script(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.data_postoffload_script_.Set(value, GetArenaForAllocation());
}
inline std::string* MissionManager::_internal_mutable_data_postoffload_script() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.data_postoffload_script_.Mutable(GetArenaForAllocation());
}
inline std::string* MissionManager::release_data_postoffload_script() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.data_postoffload_script)
  if (!_internal_has_data_postoffload_script()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.data_postoffload_script_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_postoffload_script_.IsDefault()) {
    _impl_.data_postoffload_script_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MissionManager::set_allocated_data_postoffload_script(std::string* data_postoffload_script) {
  if (data_postoffload_script != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.data_postoffload_script_.SetAllocated(data_postoffload_script, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_postoffload_script_.IsDefault()) {
    _impl_.data_postoffload_script_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.data_postoffload_script)
}
 
// required string log_dir = 72;
inline bool MissionManager::_internal_has_log_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MissionManager::has_log_dir() const {
  return _internal_has_log_dir();
}
inline void MissionManager::clear_log_dir() {
  _impl_.log_dir_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& MissionManager::log_dir() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.log_dir)
  return _internal_log_dir();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MissionManager::set_log_dir(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.log_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.log_dir)
}
inline std::string* MissionManager::mutable_log_dir() {
  std::string* _s = _internal_mutable_log_dir();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.log_dir)
  return _s;
}
inline const std::string& MissionManager::_internal_log_dir() const {
  return _impl_.log_dir_.Get();
}
inline void MissionManager::_internal_set_log_dir(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.log_dir_.Set(value, GetArenaForAllocation());
}
inline std::string* MissionManager::_internal_mutable_log_dir() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.log_dir_.Mutable(GetArenaForAllocation());
}
inline std::string* MissionManager::release_log_dir() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.log_dir)
  if (!_internal_has_log_dir()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.log_dir_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.log_dir_.IsDefault()) {
    _impl_.log_dir_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MissionManager::set_allocated_log_dir(std::string* log_dir) {
  if (log_dir != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.log_dir_.SetAllocated(log_dir, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.log_dir_.IsDefault()) {
    _impl_.log_dir_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.log_dir)
}
 
// optional string log_staging_dir = 73 [default = "/var/log/jaiabot/staging"];
inline bool MissionManager::_internal_has_log_staging_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MissionManager::has_log_staging_dir() const {
  return _internal_has_log_staging_dir();
}
inline void MissionManager::clear_log_staging_dir() {
  _impl_.log_staging_dir_.ClearToDefault(::jaiabot::config::MissionManager::Impl_::_i_give_permission_to_break_this_code_default_log_staging_dir_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& MissionManager::log_staging_dir() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.log_staging_dir)
  if (_impl_.log_staging_dir_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_log_staging_dir_.get();
  return _internal_log_staging_dir();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MissionManager::set_log_staging_dir(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.log_staging_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.log_staging_dir)
}
inline std::string* MissionManager::mutable_log_staging_dir() {
  std::string* _s = _internal_mutable_log_staging_dir();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.log_staging_dir)
  return _s;
}
inline const std::string& MissionManager::_internal_log_staging_dir() const {
  return _impl_.log_staging_dir_.Get();
}
inline void MissionManager::_internal_set_log_staging_dir(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.log_staging_dir_.Set(value, GetArenaForAllocation());
}
inline std::string* MissionManager::_internal_mutable_log_staging_dir() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.log_staging_dir_.Mutable(::jaiabot::config::MissionManager::Impl_::_i_give_permission_to_break_this_code_default_log_staging_dir_, GetArenaForAllocation());
}
inline std::string* MissionManager::release_log_staging_dir() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.log_staging_dir)
  if (!_internal_has_log_staging_dir()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.log_staging_dir_.Release();
  return p;
}
inline void MissionManager::set_allocated_log_staging_dir(std::string* log_staging_dir) {
  if (log_staging_dir != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.log_staging_dir_.SetAllocated(log_staging_dir, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.log_staging_dir)
}
 
// optional string log_archive_dir = 74 [default = "/var/log/jaiabot/archive"];
inline bool MissionManager::_internal_has_log_archive_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MissionManager::has_log_archive_dir() const {
  return _internal_has_log_archive_dir();
}
inline void MissionManager::clear_log_archive_dir() {
  _impl_.log_archive_dir_.ClearToDefault(::jaiabot::config::MissionManager::Impl_::_i_give_permission_to_break_this_code_default_log_archive_dir_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& MissionManager::log_archive_dir() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.log_archive_dir)
  if (_impl_.log_archive_dir_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_log_archive_dir_.get();
  return _internal_log_archive_dir();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MissionManager::set_log_archive_dir(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.log_archive_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.log_archive_dir)
}
inline std::string* MissionManager::mutable_log_archive_dir() {
  std::string* _s = _internal_mutable_log_archive_dir();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.log_archive_dir)
  return _s;
}
inline const std::string& MissionManager::_internal_log_archive_dir() const {
  return _impl_.log_archive_dir_.Get();
}
inline void MissionManager::_internal_set_log_archive_dir(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.log_archive_dir_.Set(value, GetArenaForAllocation());
}
inline std::string* MissionManager::_internal_mutable_log_archive_dir() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.log_archive_dir_.Mutable(::jaiabot::config::MissionManager::Impl_::_i_give_permission_to_break_this_code_default_log_archive_dir_, GetArenaForAllocation());
}
inline std::string* MissionManager::release_log_archive_dir() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.log_archive_dir)
  if (!_internal_has_log_archive_dir()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.log_archive_dir_.Release();
  return p;
}
inline void MissionManager::set_allocated_log_archive_dir(std::string* log_archive_dir) {
  if (log_archive_dir != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.log_archive_dir_.SetAllocated(log_archive_dir, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.log_archive_dir)
}
 
// optional .jaiabot.config.MissionManager.DownloadFileTypes data_offload_exclude = 75;
inline bool MissionManager::_internal_has_data_offload_exclude() const {
  bool value = (_impl_._has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline bool MissionManager::has_data_offload_exclude() const {
  return _internal_has_data_offload_exclude();
}
inline void MissionManager::clear_data_offload_exclude() {
  _impl_.data_offload_exclude_ = 1;
  _impl_._has_bits_[1] &= ~0x00100000u;
}
inline ::jaiabot::config::MissionManager_DownloadFileTypes MissionManager::_internal_data_offload_exclude() const {
  return static_cast< ::jaiabot::config::MissionManager_DownloadFileTypes >(_impl_.data_offload_exclude_);
}
inline ::jaiabot::config::MissionManager_DownloadFileTypes MissionManager::data_offload_exclude() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.data_offload_exclude)
  return _internal_data_offload_exclude();
}
inline void MissionManager::_internal_set_data_offload_exclude(::jaiabot::config::MissionManager_DownloadFileTypes value) {
  assert(::jaiabot::config::MissionManager_DownloadFileTypes_IsValid(value));
  _impl_._has_bits_[1] |= 0x00100000u;
  _impl_.data_offload_exclude_ = value;
}
inline void MissionManager::set_data_offload_exclude(::jaiabot::config::MissionManager_DownloadFileTypes value) {
  _internal_set_data_offload_exclude(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.data_offload_exclude)
}
 
// repeated .jaiabot.config.MissionManager.EngineeringTestMode test_mode = 80;
inline int MissionManager::_internal_test_mode_size() const {
  return _impl_.test_mode_.size();
}
inline int MissionManager::test_mode_size() const {
  return _internal_test_mode_size();
}
inline void MissionManager::clear_test_mode() {
  _impl_.test_mode_.Clear();
}
inline ::jaiabot::config::MissionManager_EngineeringTestMode MissionManager::_internal_test_mode(int index) const {
  return static_cast< ::jaiabot::config::MissionManager_EngineeringTestMode >(_impl_.test_mode_.Get(index));
}
inline ::jaiabot::config::MissionManager_EngineeringTestMode MissionManager::test_mode(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.test_mode)
  return _internal_test_mode(index);
}
inline void MissionManager::set_test_mode(int index, ::jaiabot::config::MissionManager_EngineeringTestMode value) {
  assert(::jaiabot::config::MissionManager_EngineeringTestMode_IsValid(value));
  _impl_.test_mode_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.test_mode)
}
inline void MissionManager::_internal_add_test_mode(::jaiabot::config::MissionManager_EngineeringTestMode value) {
  assert(::jaiabot::config::MissionManager_EngineeringTestMode_IsValid(value));
  _impl_.test_mode_.Add(value);
}
inline void MissionManager::add_test_mode(::jaiabot::config::MissionManager_EngineeringTestMode value) {
  _internal_add_test_mode(value);
  // @@protoc_insertion_point(field_add:jaiabot.config.MissionManager.test_mode)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
MissionManager::test_mode() const {
  // @@protoc_insertion_point(field_list:jaiabot.config.MissionManager.test_mode)
  return _impl_.test_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::_internal_mutable_test_mode() {
  return &_impl_.test_mode_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::mutable_test_mode() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.config.MissionManager.test_mode)
  return _internal_mutable_test_mode();
}
 
// repeated .jaiabot.protobuf.Error ignore_error = 81;
inline int MissionManager::_internal_ignore_error_size() const {
  return _impl_.ignore_error_.size();
}
inline int MissionManager::ignore_error_size() const {
  return _internal_ignore_error_size();
}
inline void MissionManager::clear_ignore_error() {
  _impl_.ignore_error_.Clear();
}
inline ::jaiabot::protobuf::Error MissionManager::_internal_ignore_error(int index) const {
  return static_cast< ::jaiabot::protobuf::Error >(_impl_.ignore_error_.Get(index));
}
inline ::jaiabot::protobuf::Error MissionManager::ignore_error(int index) const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.ignore_error)
  return _internal_ignore_error(index);
}
inline void MissionManager::set_ignore_error(int index, ::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_.ignore_error_.Set(index, value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.ignore_error)
}
inline void MissionManager::_internal_add_ignore_error(::jaiabot::protobuf::Error value) {
  assert(::jaiabot::protobuf::Error_IsValid(value));
  _impl_.ignore_error_.Add(value);
}
inline void MissionManager::add_ignore_error(::jaiabot::protobuf::Error value) {
  _internal_add_ignore_error(value);
  // @@protoc_insertion_point(field_add:jaiabot.config.MissionManager.ignore_error)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
MissionManager::ignore_error() const {
  // @@protoc_insertion_point(field_list:jaiabot.config.MissionManager.ignore_error)
  return _impl_.ignore_error_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::_internal_mutable_ignore_error() {
  return &_impl_.ignore_error_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
MissionManager::mutable_ignore_error() {
  // @@protoc_insertion_point(field_mutable_list:jaiabot.config.MissionManager.ignore_error)
  return _internal_mutable_ignore_error();
}
 
// optional bool is_sim = 82 [default = false];
inline bool MissionManager::_internal_has_is_sim() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool MissionManager::has_is_sim() const {
  return _internal_has_is_sim();
}
inline void MissionManager::clear_is_sim() {
  _impl_.is_sim_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool MissionManager::_internal_is_sim() const {
  return _impl_.is_sim_;
}
inline bool MissionManager::is_sim() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.is_sim)
  return _internal_is_sim();
}
inline void MissionManager::_internal_set_is_sim(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.is_sim_ = value;
}
inline void MissionManager::set_is_sim(bool value) {
  _internal_set_is_sim(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.is_sim)
}
 
// optional double hard_bottom_type_acceleration = 84 [default = 100];
inline bool MissionManager::_internal_has_hard_bottom_type_acceleration() const {
  bool value = (_impl_._has_bits_[1] & 0x00400000u) != 0;
  return value;
}
inline bool MissionManager::has_hard_bottom_type_acceleration() const {
  return _internal_has_hard_bottom_type_acceleration();
}
inline void MissionManager::clear_hard_bottom_type_acceleration() {
  _impl_.hard_bottom_type_acceleration_ = 100;
  _impl_._has_bits_[1] &= ~0x00400000u;
}
inline double MissionManager::_internal_hard_bottom_type_acceleration() const {
  return _impl_.hard_bottom_type_acceleration_;
}
inline double MissionManager::hard_bottom_type_acceleration() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.hard_bottom_type_acceleration)
  return _internal_hard_bottom_type_acceleration();
}
inline void MissionManager::_internal_set_hard_bottom_type_acceleration(double value) {
  _impl_._has_bits_[1] |= 0x00400000u;
  _impl_.hard_bottom_type_acceleration_ = value;
}
inline void MissionManager::set_hard_bottom_type_acceleration(double value) {
  _internal_set_hard_bottom_type_acceleration(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.hard_bottom_type_acceleration)
}
 
// optional int32 failed_startup_log_timeout = 85 [default = 300, (.dccl.field) = {
inline bool MissionManager::_internal_has_failed_startup_log_timeout() const {
  bool value = (_impl_._has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline bool MissionManager::has_failed_startup_log_timeout() const {
  return _internal_has_failed_startup_log_timeout();
}
inline void MissionManager::clear_failed_startup_log_timeout() {
  _impl_.failed_startup_log_timeout_ = 300;
  _impl_._has_bits_[1] &= ~0x00200000u;
}
inline int32_t MissionManager::_internal_failed_startup_log_timeout() const {
  return _impl_.failed_startup_log_timeout_;
}
inline int32_t MissionManager::failed_startup_log_timeout() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.failed_startup_log_timeout)
  return _internal_failed_startup_log_timeout();
}
inline void MissionManager::_internal_set_failed_startup_log_timeout(int32_t value) {
  _impl_._has_bits_[1] |= 0x00200000u;
  _impl_.failed_startup_log_timeout_ = value;
}
inline void MissionManager::set_failed_startup_log_timeout(int32_t value) {
  _internal_set_failed_startup_log_timeout(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.failed_startup_log_timeout)
}
 
// optional int32 waypoint_with_no_task_slip_radius = 86 [default = 15];
inline bool MissionManager::_internal_has_waypoint_with_no_task_slip_radius() const {
  bool value = (_impl_._has_bits_[1] & 0x00800000u) != 0;
  return value;
}
inline bool MissionManager::has_waypoint_with_no_task_slip_radius() const {
  return _internal_has_waypoint_with_no_task_slip_radius();
}
inline void MissionManager::clear_waypoint_with_no_task_slip_radius() {
  _impl_.waypoint_with_no_task_slip_radius_ = 15;
  _impl_._has_bits_[1] &= ~0x00800000u;
}
inline int32_t MissionManager::_internal_waypoint_with_no_task_slip_radius() const {
  return _impl_.waypoint_with_no_task_slip_radius_;
}
inline int32_t MissionManager::waypoint_with_no_task_slip_radius() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.waypoint_with_no_task_slip_radius)
  return _internal_waypoint_with_no_task_slip_radius();
}
inline void MissionManager::_internal_set_waypoint_with_no_task_slip_radius(int32_t value) {
  _impl_._has_bits_[1] |= 0x00800000u;
  _impl_.waypoint_with_no_task_slip_radius_ = value;
}
inline void MissionManager::set_waypoint_with_no_task_slip_radius(int32_t value) {
  _internal_set_waypoint_with_no_task_slip_radius(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.waypoint_with_no_task_slip_radius)
}
 
// optional int32 waypoint_with_task_slip_radius = 87 [default = 5];
inline bool MissionManager::_internal_has_waypoint_with_task_slip_radius() const {
  bool value = (_impl_._has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline bool MissionManager::has_waypoint_with_task_slip_radius() const {
  return _internal_has_waypoint_with_task_slip_radius();
}
inline void MissionManager::clear_waypoint_with_task_slip_radius() {
  _impl_.waypoint_with_task_slip_radius_ = 5;
  _impl_._has_bits_[1] &= ~0x01000000u;
}
inline int32_t MissionManager::_internal_waypoint_with_task_slip_radius() const {
  return _impl_.waypoint_with_task_slip_radius_;
}
inline int32_t MissionManager::waypoint_with_task_slip_radius() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.waypoint_with_task_slip_radius)
  return _internal_waypoint_with_task_slip_radius();
}
inline void MissionManager::_internal_set_waypoint_with_task_slip_radius(int32_t value) {
  _impl_._has_bits_[1] |= 0x01000000u;
  _impl_.waypoint_with_task_slip_radius_ = value;
}
inline void MissionManager::set_waypoint_with_task_slip_radius(int32_t value) {
  _internal_set_waypoint_with_task_slip_radius(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.waypoint_with_task_slip_radius)
}
 
// optional .jaiabot.config.MissionManager.ResolveNoForwardProgress resolve_no_forward_progress = 88;
inline bool MissionManager::_internal_has_resolve_no_forward_progress() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.resolve_no_forward_progress_ != nullptr);
  return value;
}
inline bool MissionManager::has_resolve_no_forward_progress() const {
  return _internal_has_resolve_no_forward_progress();
}
inline void MissionManager::clear_resolve_no_forward_progress() {
  if (_impl_.resolve_no_forward_progress_ != nullptr) _impl_.resolve_no_forward_progress_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::jaiabot::config::MissionManager_ResolveNoForwardProgress& MissionManager::_internal_resolve_no_forward_progress() const {
  const ::jaiabot::config::MissionManager_ResolveNoForwardProgress* p = _impl_.resolve_no_forward_progress_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::config::MissionManager_ResolveNoForwardProgress&>(
      ::jaiabot::config::_MissionManager_ResolveNoForwardProgress_default_instance_);
}
inline const ::jaiabot::config::MissionManager_ResolveNoForwardProgress& MissionManager::resolve_no_forward_progress() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.resolve_no_forward_progress)
  return _internal_resolve_no_forward_progress();
}
inline void MissionManager::unsafe_arena_set_allocated_resolve_no_forward_progress(
    ::jaiabot::config::MissionManager_ResolveNoForwardProgress* resolve_no_forward_progress) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resolve_no_forward_progress_);
  }
  _impl_.resolve_no_forward_progress_ = resolve_no_forward_progress;
  if (resolve_no_forward_progress) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.resolve_no_forward_progress)
}
inline ::jaiabot::config::MissionManager_ResolveNoForwardProgress* MissionManager::release_resolve_no_forward_progress() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* temp = _impl_.resolve_no_forward_progress_;
  _impl_.resolve_no_forward_progress_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::config::MissionManager_ResolveNoForwardProgress* MissionManager::unsafe_arena_release_resolve_no_forward_progress() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.resolve_no_forward_progress)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* temp = _impl_.resolve_no_forward_progress_;
  _impl_.resolve_no_forward_progress_ = nullptr;
  return temp;
}
inline ::jaiabot::config::MissionManager_ResolveNoForwardProgress* MissionManager::_internal_mutable_resolve_no_forward_progress() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.resolve_no_forward_progress_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::config::MissionManager_ResolveNoForwardProgress>(GetArenaForAllocation());
    _impl_.resolve_no_forward_progress_ = p;
  }
  return _impl_.resolve_no_forward_progress_;
}
inline ::jaiabot::config::MissionManager_ResolveNoForwardProgress* MissionManager::mutable_resolve_no_forward_progress() {
  ::jaiabot::config::MissionManager_ResolveNoForwardProgress* _msg = _internal_mutable_resolve_no_forward_progress();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.resolve_no_forward_progress)
  return _msg;
}
inline void MissionManager::set_allocated_resolve_no_forward_progress(::jaiabot::config::MissionManager_ResolveNoForwardProgress* resolve_no_forward_progress) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.resolve_no_forward_progress_;
  }
  if (resolve_no_forward_progress) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(resolve_no_forward_progress);
    if (message_arena != submessage_arena) {
      resolve_no_forward_progress = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, resolve_no_forward_progress, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.resolve_no_forward_progress_ = resolve_no_forward_progress;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.resolve_no_forward_progress)
}
 
// required uint32 subnet_mask = 89;
inline bool MissionManager::_internal_has_subnet_mask() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool MissionManager::has_subnet_mask() const {
  return _internal_has_subnet_mask();
}
inline void MissionManager::clear_subnet_mask() {
  _impl_.subnet_mask_ = 0u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t MissionManager::_internal_subnet_mask() const {
  return _impl_.subnet_mask_;
}
inline uint32_t MissionManager::subnet_mask() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.subnet_mask)
  return _internal_subnet_mask();
}
inline void MissionManager::_internal_set_subnet_mask(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.subnet_mask_ = value;
}
inline void MissionManager::set_subnet_mask(uint32_t value) {
  _internal_set_subnet_mask(value);
  // @@protoc_insertion_point(field_set:jaiabot.config.MissionManager.subnet_mask)
}
 
// optional .jaiabot.protobuf.CameraCommand start_camera_command = 90;
inline bool MissionManager::_internal_has_start_camera_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_camera_command_ != nullptr);
  return value;
}
inline bool MissionManager::has_start_camera_command() const {
  return _internal_has_start_camera_command();
}
inline const ::jaiabot::protobuf::CameraCommand& MissionManager::_internal_start_camera_command() const {
  const ::jaiabot::protobuf::CameraCommand* p = _impl_.start_camera_command_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::CameraCommand&>(
      ::jaiabot::protobuf::_CameraCommand_default_instance_);
}
inline const ::jaiabot::protobuf::CameraCommand& MissionManager::start_camera_command() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.start_camera_command)
  return _internal_start_camera_command();
}
inline void MissionManager::unsafe_arena_set_allocated_start_camera_command(
    ::jaiabot::protobuf::CameraCommand* start_camera_command) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_camera_command_);
  }
  _impl_.start_camera_command_ = start_camera_command;
  if (start_camera_command) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.start_camera_command)
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::release_start_camera_command() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::jaiabot::protobuf::CameraCommand* temp = _impl_.start_camera_command_;
  _impl_.start_camera_command_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::unsafe_arena_release_start_camera_command() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.start_camera_command)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::jaiabot::protobuf::CameraCommand* temp = _impl_.start_camera_command_;
  _impl_.start_camera_command_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::_internal_mutable_start_camera_command() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.start_camera_command_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::CameraCommand>(GetArenaForAllocation());
    _impl_.start_camera_command_ = p;
  }
  return _impl_.start_camera_command_;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::mutable_start_camera_command() {
  ::jaiabot::protobuf::CameraCommand* _msg = _internal_mutable_start_camera_command();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.start_camera_command)
  return _msg;
}
inline void MissionManager::set_allocated_start_camera_command(::jaiabot::protobuf::CameraCommand* start_camera_command) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_camera_command_);
  }
  if (start_camera_command) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_camera_command));
    if (message_arena != submessage_arena) {
      start_camera_command = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start_camera_command, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.start_camera_command_ = start_camera_command;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.start_camera_command)
}
 
// optional .jaiabot.protobuf.CameraCommand stop_camera_command = 91;
inline bool MissionManager::_internal_has_stop_camera_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stop_camera_command_ != nullptr);
  return value;
}
inline bool MissionManager::has_stop_camera_command() const {
  return _internal_has_stop_camera_command();
}
inline const ::jaiabot::protobuf::CameraCommand& MissionManager::_internal_stop_camera_command() const {
  const ::jaiabot::protobuf::CameraCommand* p = _impl_.stop_camera_command_;
  return p != nullptr ? *p : reinterpret_cast<const ::jaiabot::protobuf::CameraCommand&>(
      ::jaiabot::protobuf::_CameraCommand_default_instance_);
}
inline const ::jaiabot::protobuf::CameraCommand& MissionManager::stop_camera_command() const {
  // @@protoc_insertion_point(field_get:jaiabot.config.MissionManager.stop_camera_command)
  return _internal_stop_camera_command();
}
inline void MissionManager::unsafe_arena_set_allocated_stop_camera_command(
    ::jaiabot::protobuf::CameraCommand* stop_camera_command) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stop_camera_command_);
  }
  _impl_.stop_camera_command_ = stop_camera_command;
  if (stop_camera_command) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:jaiabot.config.MissionManager.stop_camera_command)
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::release_stop_camera_command() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::jaiabot::protobuf::CameraCommand* temp = _impl_.stop_camera_command_;
  _impl_.stop_camera_command_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::unsafe_arena_release_stop_camera_command() {
  // @@protoc_insertion_point(field_release:jaiabot.config.MissionManager.stop_camera_command)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::jaiabot::protobuf::CameraCommand* temp = _impl_.stop_camera_command_;
  _impl_.stop_camera_command_ = nullptr;
  return temp;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::_internal_mutable_stop_camera_command() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.stop_camera_command_ == nullptr) {
    auto* p = CreateMaybeMessage<::jaiabot::protobuf::CameraCommand>(GetArenaForAllocation());
    _impl_.stop_camera_command_ = p;
  }
  return _impl_.stop_camera_command_;
}
inline ::jaiabot::protobuf::CameraCommand* MissionManager::mutable_stop_camera_command() {
  ::jaiabot::protobuf::CameraCommand* _msg = _internal_mutable_stop_camera_command();
  // @@protoc_insertion_point(field_mutable:jaiabot.config.MissionManager.stop_camera_command)
  return _msg;
}
inline void MissionManager::set_allocated_stop_camera_command(::jaiabot::protobuf::CameraCommand* stop_camera_command) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stop_camera_command_);
  }
  if (stop_camera_command) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stop_camera_command));
    if (message_arena != submessage_arena) {
      stop_camera_command = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stop_camera_command, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.stop_camera_command_ = stop_camera_command;
  // @@protoc_insertion_point(field_set_allocated:jaiabot.config.MissionManager.stop_camera_command)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace config
}  // namespace jaiabot
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::jaiabot::config::MissionManager_RemoteControlSetpointEnd> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::config::MissionManager_RemoteControlSetpointEnd>() {
  return ::jaiabot::config::MissionManager_RemoteControlSetpointEnd_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::config::MissionManager_DownloadFileTypes> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::config::MissionManager_DownloadFileTypes>() {
  return ::jaiabot::config::MissionManager_DownloadFileTypes_descriptor();
}
template <> struct is_proto_enum< ::jaiabot::config::MissionManager_EngineeringTestMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::jaiabot::config::MissionManager_EngineeringTestMode>() {
  return ::jaiabot::config::MissionManager_EngineeringTestMode_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_bin_2fmission_5fmanager_2fconfig_2eproto