pAcommsHandler_config.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/moos/protobuf/pAcommsHandler_config.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_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/moos/protobuf/goby_moos_app.pb.h"
#include "goby/acomms/protobuf/driver_base.pb.h"
#include "goby/acomms/protobuf/queue.pb.h"
#include "goby/acomms/protobuf/amac_config.pb.h"
#include "goby/acomms/protobuf/dccl.pb.h"
#include "goby/acomms/protobuf/route.pb.h"
#include "goby/moos/protobuf/translator.pb.h"
#include "goby/protobuf/option_extensions.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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto;
namespace goby {
namespace apps {
namespace moos {
namespace protobuf {
class pAcommsHandlerConfig;
struct pAcommsHandlerConfigDefaultTypeInternal;
extern pAcommsHandlerConfigDefaultTypeInternal _pAcommsHandlerConfig_default_instance_;
class pAcommsHandlerConfig_DriverFailureApproach;
struct pAcommsHandlerConfig_DriverFailureApproachDefaultTypeInternal;
extern pAcommsHandlerConfig_DriverFailureApproachDefaultTypeInternal _pAcommsHandlerConfig_DriverFailureApproach_default_instance_;
class pAcommsHandlerConfig_MOOSVariables;
struct pAcommsHandlerConfig_MOOSVariablesDefaultTypeInternal;
extern pAcommsHandlerConfig_MOOSVariablesDefaultTypeInternal _pAcommsHandlerConfig_MOOSVariables_default_instance_;
}  // namespace protobuf
}  // namespace moos
}  // namespace apps
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::apps::moos::protobuf::pAcommsHandlerConfig* Arena::CreateMaybeMessage<::goby::apps::moos::protobuf::pAcommsHandlerConfig>(Arena*);
template<> ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* Arena::CreateMaybeMessage<::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach>(Arena*);
template<> ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* Arena::CreateMaybeMessage<::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace apps {
namespace moos {
namespace protobuf {
 
enum pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique : int {
  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER = 1,
  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_MOVE_LISTEN_DRIVER_TO_PRIMARY = 2,
  pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY = 3
};
bool pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(int value);
constexpr pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MIN = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER;
constexpr pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY;
constexpr int pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_ARRAYSIZE = pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
template<typename T>
inline const std::string& pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Name(T enum_t_value) {
  static_assert(::std::is_same<T, pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor(), enum_t_value);
}
inline bool pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique>(
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor(), name, value);
}
// ===================================================================
 
class pAcommsHandlerConfig_DriverFailureApproach final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach) */ {
 public:
  inline pAcommsHandlerConfig_DriverFailureApproach() : pAcommsHandlerConfig_DriverFailureApproach(nullptr) {}
  ~pAcommsHandlerConfig_DriverFailureApproach() override;
  explicit PROTOBUF_CONSTEXPR pAcommsHandlerConfig_DriverFailureApproach(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  pAcommsHandlerConfig_DriverFailureApproach(const pAcommsHandlerConfig_DriverFailureApproach& from);
  pAcommsHandlerConfig_DriverFailureApproach(pAcommsHandlerConfig_DriverFailureApproach&& from) noexcept
    : pAcommsHandlerConfig_DriverFailureApproach() {
    *this = ::std::move(from);
  }
 
  inline pAcommsHandlerConfig_DriverFailureApproach& operator=(const pAcommsHandlerConfig_DriverFailureApproach& from) {
    CopyFrom(from);
    return *this;
  }
  inline pAcommsHandlerConfig_DriverFailureApproach& operator=(pAcommsHandlerConfig_DriverFailureApproach&& 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 pAcommsHandlerConfig_DriverFailureApproach& default_instance() {
    return *internal_default_instance();
  }
  static inline const pAcommsHandlerConfig_DriverFailureApproach* internal_default_instance() {
    return reinterpret_cast<const pAcommsHandlerConfig_DriverFailureApproach*>(
               &_pAcommsHandlerConfig_DriverFailureApproach_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(pAcommsHandlerConfig_DriverFailureApproach& a, pAcommsHandlerConfig_DriverFailureApproach& b) {
    a.Swap(&b);
  }
  inline void Swap(pAcommsHandlerConfig_DriverFailureApproach* 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(pAcommsHandlerConfig_DriverFailureApproach* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  pAcommsHandlerConfig_DriverFailureApproach* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<pAcommsHandlerConfig_DriverFailureApproach>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const pAcommsHandlerConfig_DriverFailureApproach& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const pAcommsHandlerConfig_DriverFailureApproach& from) {
    pAcommsHandlerConfig_DriverFailureApproach::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(pAcommsHandlerConfig_DriverFailureApproach* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach";
  }
  protected:
  explicit pAcommsHandlerConfig_DriverFailureApproach(::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 pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique DriverFailureTechnique;
  static constexpr DriverFailureTechnique CONTINUALLY_RESTART_DRIVER =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_CONTINUALLY_RESTART_DRIVER;
  static constexpr DriverFailureTechnique MOVE_LISTEN_DRIVER_TO_PRIMARY =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_MOVE_LISTEN_DRIVER_TO_PRIMARY;
  static constexpr DriverFailureTechnique DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DISABLE_AND_MOVE_LISTEN_DRIVER_TO_PRIMARY;
  static inline bool DriverFailureTechnique_IsValid(int value) {
    return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(value);
  }
  static constexpr DriverFailureTechnique DriverFailureTechnique_MIN =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MIN;
  static constexpr DriverFailureTechnique DriverFailureTechnique_MAX =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_MAX;
  static constexpr int DriverFailureTechnique_ARRAYSIZE =
    pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_DriverFailureTechnique_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DriverFailureTechnique_descriptor() {
    return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
  }
  template<typename T>
  static inline const std::string& DriverFailureTechnique_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DriverFailureTechnique>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DriverFailureTechnique_Name.");
    return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Name(enum_t_value);
  }
  static inline bool DriverFailureTechnique_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DriverFailureTechnique* value) {
    return pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kNewDriverBackoffSecFieldNumber = 3,
    kTechniqueFieldNumber = 1,
    kDriverBackoffSecFieldNumber = 2,
  };
  // optional int32 new_driver_backoff_sec = 3 [default = 5, (.goby.field) = {
  bool has_new_driver_backoff_sec() const;
  private:
  bool _internal_has_new_driver_backoff_sec() const;
  public:
  void clear_new_driver_backoff_sec();
  int32_t new_driver_backoff_sec() const;
  void set_new_driver_backoff_sec(int32_t value);
  private:
  int32_t _internal_new_driver_backoff_sec() const;
  void _internal_set_new_driver_backoff_sec(int32_t value);
  public:
 
  // optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.DriverFailureTechnique technique = 1 [default = CONTINUALLY_RESTART_DRIVER];
  bool has_technique() const;
  private:
  bool _internal_has_technique() const;
  public:
  void clear_technique();
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique technique() const;
  void set_technique(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value);
  private:
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique _internal_technique() const;
  void _internal_set_technique(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value);
  public:
 
  // optional int32 driver_backoff_sec = 2 [default = 60, (.goby.field) = {
  bool has_driver_backoff_sec() const;
  private:
  bool _internal_has_driver_backoff_sec() const;
  public:
  void clear_driver_backoff_sec();
  int32_t driver_backoff_sec() const;
  void set_driver_backoff_sec(int32_t value);
  private:
  int32_t _internal_driver_backoff_sec() const;
  void _internal_set_driver_backoff_sec(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach)
 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 new_driver_backoff_sec_;
    int technique_;
    int32_t driver_backoff_sec_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto;
};
// -------------------------------------------------------------------
 
class pAcommsHandlerConfig_MOOSVariables final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables) */ {
 public:
  inline pAcommsHandlerConfig_MOOSVariables() : pAcommsHandlerConfig_MOOSVariables(nullptr) {}
  ~pAcommsHandlerConfig_MOOSVariables() override;
  explicit PROTOBUF_CONSTEXPR pAcommsHandlerConfig_MOOSVariables(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  pAcommsHandlerConfig_MOOSVariables(const pAcommsHandlerConfig_MOOSVariables& from);
  pAcommsHandlerConfig_MOOSVariables(pAcommsHandlerConfig_MOOSVariables&& from) noexcept
    : pAcommsHandlerConfig_MOOSVariables() {
    *this = ::std::move(from);
  }
 
  inline pAcommsHandlerConfig_MOOSVariables& operator=(const pAcommsHandlerConfig_MOOSVariables& from) {
    CopyFrom(from);
    return *this;
  }
  inline pAcommsHandlerConfig_MOOSVariables& operator=(pAcommsHandlerConfig_MOOSVariables&& 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 pAcommsHandlerConfig_MOOSVariables& default_instance() {
    return *internal_default_instance();
  }
  static inline const pAcommsHandlerConfig_MOOSVariables* internal_default_instance() {
    return reinterpret_cast<const pAcommsHandlerConfig_MOOSVariables*>(
               &_pAcommsHandlerConfig_MOOSVariables_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(pAcommsHandlerConfig_MOOSVariables& a, pAcommsHandlerConfig_MOOSVariables& b) {
    a.Swap(&b);
  }
  inline void Swap(pAcommsHandlerConfig_MOOSVariables* 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(pAcommsHandlerConfig_MOOSVariables* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  pAcommsHandlerConfig_MOOSVariables* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<pAcommsHandlerConfig_MOOSVariables>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const pAcommsHandlerConfig_MOOSVariables& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const pAcommsHandlerConfig_MOOSVariables& from) {
    pAcommsHandlerConfig_MOOSVariables::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(pAcommsHandlerConfig_MOOSVariables* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables";
  }
  protected:
  explicit pAcommsHandlerConfig_MOOSVariables(::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 {
    kPrefixFieldNumber = 1,
    kDriverRawInFieldNumber = 10,
    kDriverRawOutFieldNumber = 11,
    kDriverRawMsgInFieldNumber = 12,
    kDriverRawMsgOutFieldNumber = 13,
    kDriverReceiveFieldNumber = 14,
    kDriverTransmitFieldNumber = 15,
    kDriverCfgUpdateFieldNumber = 16,
    kQueueReceiveFieldNumber = 100,
    kQueueTransmitFieldNumber = 101,
    kQueueAckTransmissionFieldNumber = 102,
    kQueueAckOriginalMsgFieldNumber = 103,
    kQueueExpireFieldNumber = 104,
    kQueueSizeFieldNumber = 105,
    kQueueFlushFieldNumber = 106,
    kMacCycleUpdateFieldNumber = 200,
    kMacInitiateTransmissionFieldNumber = 201,
    kMacSlotStartFieldNumber = 202,
    kConfigFileFieldNumber = 300,
    kConfigFileRequestFieldNumber = 301,
    kDriverResetFieldNumber = 400,
    kIfrontseatDataOutFieldNumber = 500,
  };
  // optional string prefix = 1 [default = "ACOMMS_", (.goby.field) = {
  bool has_prefix() const;
  private:
  bool _internal_has_prefix() const;
  public:
  void clear_prefix();
  const std::string& prefix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prefix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prefix();
  PROTOBUF_NODISCARD std::string* release_prefix();
  void set_allocated_prefix(std::string* prefix);
  private:
  const std::string& _internal_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prefix(const std::string& value);
  std::string* _internal_mutable_prefix();
  public:
 
  // optional string driver_raw_in = 10 [default = "NMEA_IN"];
  bool has_driver_raw_in() const;
  private:
  bool _internal_has_driver_raw_in() const;
  public:
  void clear_driver_raw_in();
  const std::string& driver_raw_in() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_raw_in(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_raw_in();
  PROTOBUF_NODISCARD std::string* release_driver_raw_in();
  void set_allocated_driver_raw_in(std::string* driver_raw_in);
  private:
  const std::string& _internal_driver_raw_in() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_raw_in(const std::string& value);
  std::string* _internal_mutable_driver_raw_in();
  public:
 
  // optional string driver_raw_out = 11 [default = "NMEA_OUT"];
  bool has_driver_raw_out() const;
  private:
  bool _internal_has_driver_raw_out() const;
  public:
  void clear_driver_raw_out();
  const std::string& driver_raw_out() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_raw_out(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_raw_out();
  PROTOBUF_NODISCARD std::string* release_driver_raw_out();
  void set_allocated_driver_raw_out(std::string* driver_raw_out);
  private:
  const std::string& _internal_driver_raw_out() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_raw_out(const std::string& value);
  std::string* _internal_mutable_driver_raw_out();
  public:
 
  // optional string driver_raw_msg_in = 12 [default = "RAW_INCOMING"];
  bool has_driver_raw_msg_in() const;
  private:
  bool _internal_has_driver_raw_msg_in() const;
  public:
  void clear_driver_raw_msg_in();
  const std::string& driver_raw_msg_in() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_raw_msg_in(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_raw_msg_in();
  PROTOBUF_NODISCARD std::string* release_driver_raw_msg_in();
  void set_allocated_driver_raw_msg_in(std::string* driver_raw_msg_in);
  private:
  const std::string& _internal_driver_raw_msg_in() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_raw_msg_in(const std::string& value);
  std::string* _internal_mutable_driver_raw_msg_in();
  public:
 
  // optional string driver_raw_msg_out = 13 [default = "RAW_OUTGOING"];
  bool has_driver_raw_msg_out() const;
  private:
  bool _internal_has_driver_raw_msg_out() const;
  public:
  void clear_driver_raw_msg_out();
  const std::string& driver_raw_msg_out() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_raw_msg_out(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_raw_msg_out();
  PROTOBUF_NODISCARD std::string* release_driver_raw_msg_out();
  void set_allocated_driver_raw_msg_out(std::string* driver_raw_msg_out);
  private:
  const std::string& _internal_driver_raw_msg_out() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_raw_msg_out(const std::string& value);
  std::string* _internal_mutable_driver_raw_msg_out();
  public:
 
  // optional string driver_receive = 14 [default = "MODEM_RECEIVE"];
  bool has_driver_receive() const;
  private:
  bool _internal_has_driver_receive() const;
  public:
  void clear_driver_receive();
  const std::string& driver_receive() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_receive(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_receive();
  PROTOBUF_NODISCARD std::string* release_driver_receive();
  void set_allocated_driver_receive(std::string* driver_receive);
  private:
  const std::string& _internal_driver_receive() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_receive(const std::string& value);
  std::string* _internal_mutable_driver_receive();
  public:
 
  // optional string driver_transmit = 15 [default = "MODEM_TRANSMIT"];
  bool has_driver_transmit() const;
  private:
  bool _internal_has_driver_transmit() const;
  public:
  void clear_driver_transmit();
  const std::string& driver_transmit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_transmit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_transmit();
  PROTOBUF_NODISCARD std::string* release_driver_transmit();
  void set_allocated_driver_transmit(std::string* driver_transmit);
  private:
  const std::string& _internal_driver_transmit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_transmit(const std::string& value);
  std::string* _internal_mutable_driver_transmit();
  public:
 
  // optional string driver_cfg_update = 16 [default = "DRIVER_CONFIG_UPDATE"];
  bool has_driver_cfg_update() const;
  private:
  bool _internal_has_driver_cfg_update() const;
  public:
  void clear_driver_cfg_update();
  const std::string& driver_cfg_update() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_cfg_update(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_cfg_update();
  PROTOBUF_NODISCARD std::string* release_driver_cfg_update();
  void set_allocated_driver_cfg_update(std::string* driver_cfg_update);
  private:
  const std::string& _internal_driver_cfg_update() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_cfg_update(const std::string& value);
  std::string* _internal_mutable_driver_cfg_update();
  public:
 
  // optional string queue_receive = 100 [default = "QUEUE_RECEIVE"];
  bool has_queue_receive() const;
  private:
  bool _internal_has_queue_receive() const;
  public:
  void clear_queue_receive();
  const std::string& queue_receive() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_receive(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_receive();
  PROTOBUF_NODISCARD std::string* release_queue_receive();
  void set_allocated_queue_receive(std::string* queue_receive);
  private:
  const std::string& _internal_queue_receive() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_receive(const std::string& value);
  std::string* _internal_mutable_queue_receive();
  public:
 
  // optional string queue_transmit = 101 [default = "QUEUE_TRANSMIT"];
  bool has_queue_transmit() const;
  private:
  bool _internal_has_queue_transmit() const;
  public:
  void clear_queue_transmit();
  const std::string& queue_transmit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_transmit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_transmit();
  PROTOBUF_NODISCARD std::string* release_queue_transmit();
  void set_allocated_queue_transmit(std::string* queue_transmit);
  private:
  const std::string& _internal_queue_transmit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_transmit(const std::string& value);
  std::string* _internal_mutable_queue_transmit();
  public:
 
  // optional string queue_ack_transmission = 102 [default = "ACK"];
  bool has_queue_ack_transmission() const;
  private:
  bool _internal_has_queue_ack_transmission() const;
  public:
  void clear_queue_ack_transmission();
  const std::string& queue_ack_transmission() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_ack_transmission(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_ack_transmission();
  PROTOBUF_NODISCARD std::string* release_queue_ack_transmission();
  void set_allocated_queue_ack_transmission(std::string* queue_ack_transmission);
  private:
  const std::string& _internal_queue_ack_transmission() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_ack_transmission(const std::string& value);
  std::string* _internal_mutable_queue_ack_transmission();
  public:
 
  // optional string queue_ack_original_msg = 103 [default = "ACK_ORIGINAL"];
  bool has_queue_ack_original_msg() const;
  private:
  bool _internal_has_queue_ack_original_msg() const;
  public:
  void clear_queue_ack_original_msg();
  const std::string& queue_ack_original_msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_ack_original_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_ack_original_msg();
  PROTOBUF_NODISCARD std::string* release_queue_ack_original_msg();
  void set_allocated_queue_ack_original_msg(std::string* queue_ack_original_msg);
  private:
  const std::string& _internal_queue_ack_original_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_ack_original_msg(const std::string& value);
  std::string* _internal_mutable_queue_ack_original_msg();
  public:
 
  // optional string queue_expire = 104 [default = "EXPIRE"];
  bool has_queue_expire() const;
  private:
  bool _internal_has_queue_expire() const;
  public:
  void clear_queue_expire();
  const std::string& queue_expire() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_expire(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_expire();
  PROTOBUF_NODISCARD std::string* release_queue_expire();
  void set_allocated_queue_expire(std::string* queue_expire);
  private:
  const std::string& _internal_queue_expire() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_expire(const std::string& value);
  std::string* _internal_mutable_queue_expire();
  public:
 
  // optional string queue_size = 105 [default = "QSIZE"];
  bool has_queue_size() const;
  private:
  bool _internal_has_queue_size() const;
  public:
  void clear_queue_size();
  const std::string& queue_size() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_size(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_size();
  PROTOBUF_NODISCARD std::string* release_queue_size();
  void set_allocated_queue_size(std::string* queue_size);
  private:
  const std::string& _internal_queue_size() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_size(const std::string& value);
  std::string* _internal_mutable_queue_size();
  public:
 
  // optional string queue_flush = 106 [default = "FLUSH_QUEUE"];
  bool has_queue_flush() const;
  private:
  bool _internal_has_queue_flush() const;
  public:
  void clear_queue_flush();
  const std::string& queue_flush() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_queue_flush(ArgT0&& arg0, ArgT... args);
  std::string* mutable_queue_flush();
  PROTOBUF_NODISCARD std::string* release_queue_flush();
  void set_allocated_queue_flush(std::string* queue_flush);
  private:
  const std::string& _internal_queue_flush() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_queue_flush(const std::string& value);
  std::string* _internal_mutable_queue_flush();
  public:
 
  // optional string mac_cycle_update = 200 [default = "MAC_CYCLE_UPDATE"];
  bool has_mac_cycle_update() const;
  private:
  bool _internal_has_mac_cycle_update() const;
  public:
  void clear_mac_cycle_update();
  const std::string& mac_cycle_update() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mac_cycle_update(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mac_cycle_update();
  PROTOBUF_NODISCARD std::string* release_mac_cycle_update();
  void set_allocated_mac_cycle_update(std::string* mac_cycle_update);
  private:
  const std::string& _internal_mac_cycle_update() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_cycle_update(const std::string& value);
  std::string* _internal_mutable_mac_cycle_update();
  public:
 
  // optional string mac_initiate_transmission = 201 [default = "MAC_INITIATE_TRANSMISSION"];
  bool has_mac_initiate_transmission() const;
  private:
  bool _internal_has_mac_initiate_transmission() const;
  public:
  void clear_mac_initiate_transmission();
  const std::string& mac_initiate_transmission() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mac_initiate_transmission(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mac_initiate_transmission();
  PROTOBUF_NODISCARD std::string* release_mac_initiate_transmission();
  void set_allocated_mac_initiate_transmission(std::string* mac_initiate_transmission);
  private:
  const std::string& _internal_mac_initiate_transmission() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_initiate_transmission(const std::string& value);
  std::string* _internal_mutable_mac_initiate_transmission();
  public:
 
  // optional string mac_slot_start = 202 [default = "MAC_SLOT_START"];
  bool has_mac_slot_start() const;
  private:
  bool _internal_has_mac_slot_start() const;
  public:
  void clear_mac_slot_start();
  const std::string& mac_slot_start() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mac_slot_start(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mac_slot_start();
  PROTOBUF_NODISCARD std::string* release_mac_slot_start();
  void set_allocated_mac_slot_start(std::string* mac_slot_start);
  private:
  const std::string& _internal_mac_slot_start() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_slot_start(const std::string& value);
  std::string* _internal_mutable_mac_slot_start();
  public:
 
  // optional string config_file = 300 [default = "CONFIG"];
  bool has_config_file() const;
  private:
  bool _internal_has_config_file() const;
  public:
  void clear_config_file();
  const std::string& config_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_config_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_config_file();
  PROTOBUF_NODISCARD std::string* release_config_file();
  void set_allocated_config_file(std::string* config_file);
  private:
  const std::string& _internal_config_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_config_file(const std::string& value);
  std::string* _internal_mutable_config_file();
  public:
 
  // optional string config_file_request = 301 [default = "CONFIG_REQUEST"];
  bool has_config_file_request() const;
  private:
  bool _internal_has_config_file_request() const;
  public:
  void clear_config_file_request();
  const std::string& config_file_request() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_config_file_request(ArgT0&& arg0, ArgT... args);
  std::string* mutable_config_file_request();
  PROTOBUF_NODISCARD std::string* release_config_file_request();
  void set_allocated_config_file_request(std::string* config_file_request);
  private:
  const std::string& _internal_config_file_request() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_config_file_request(const std::string& value);
  std::string* _internal_mutable_config_file_request();
  public:
 
  // optional string driver_reset = 400 [default = "DRIVER_RESET"];
  bool has_driver_reset() const;
  private:
  bool _internal_has_driver_reset() const;
  public:
  void clear_driver_reset();
  const std::string& driver_reset() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_driver_reset(ArgT0&& arg0, ArgT... args);
  std::string* mutable_driver_reset();
  PROTOBUF_NODISCARD std::string* release_driver_reset();
  void set_allocated_driver_reset(std::string* driver_reset);
  private:
  const std::string& _internal_driver_reset() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_driver_reset(const std::string& value);
  std::string* _internal_mutable_driver_reset();
  public:
 
  // optional string ifrontseat_data_out = 500 [default = "IFS_DATA_OUT"];
  bool has_ifrontseat_data_out() const;
  private:
  bool _internal_has_ifrontseat_data_out() const;
  public:
  void clear_ifrontseat_data_out();
  const std::string& ifrontseat_data_out() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ifrontseat_data_out(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ifrontseat_data_out();
  PROTOBUF_NODISCARD std::string* release_ifrontseat_data_out();
  void set_allocated_ifrontseat_data_out(std::string* ifrontseat_data_out);
  private:
  const std::string& _internal_ifrontseat_data_out() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ifrontseat_data_out(const std::string& value);
  std::string* _internal_mutable_ifrontseat_data_out();
  public:
 
  // @@protoc_insertion_point(class_scope:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables)
 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_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_prefix_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_raw_in_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_raw_in_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_raw_out_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_raw_out_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_raw_msg_in_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_raw_msg_in_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_raw_msg_out_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_raw_msg_out_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_receive_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_receive_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_transmit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_transmit_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_cfg_update_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_cfg_update_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_receive_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_receive_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_transmit_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_transmit_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_ack_transmission_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_ack_transmission_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_ack_original_msg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_ack_original_msg_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_expire_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_expire_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_size_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_queue_flush_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr queue_flush_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_mac_cycle_update_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_cycle_update_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_mac_initiate_transmission_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_initiate_transmission_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_mac_slot_start_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_slot_start_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_config_file_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr config_file_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_config_file_request_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr config_file_request_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_driver_reset_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr driver_reset_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_ifrontseat_data_out_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ifrontseat_data_out_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto;
};
// -------------------------------------------------------------------
 
class pAcommsHandlerConfig final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.apps.moos.protobuf.pAcommsHandlerConfig) */ {
 public:
  inline pAcommsHandlerConfig() : pAcommsHandlerConfig(nullptr) {}
  ~pAcommsHandlerConfig() override;
  explicit PROTOBUF_CONSTEXPR pAcommsHandlerConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  pAcommsHandlerConfig(const pAcommsHandlerConfig& from);
  pAcommsHandlerConfig(pAcommsHandlerConfig&& from) noexcept
    : pAcommsHandlerConfig() {
    *this = ::std::move(from);
  }
 
  inline pAcommsHandlerConfig& operator=(const pAcommsHandlerConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline pAcommsHandlerConfig& operator=(pAcommsHandlerConfig&& 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 pAcommsHandlerConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const pAcommsHandlerConfig* internal_default_instance() {
    return reinterpret_cast<const pAcommsHandlerConfig*>(
               &_pAcommsHandlerConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(pAcommsHandlerConfig& a, pAcommsHandlerConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(pAcommsHandlerConfig* 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(pAcommsHandlerConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  pAcommsHandlerConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<pAcommsHandlerConfig>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const pAcommsHandlerConfig& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const pAcommsHandlerConfig& from) {
    pAcommsHandlerConfig::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(pAcommsHandlerConfig* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.apps.moos.protobuf.pAcommsHandlerConfig";
  }
  protected:
  explicit pAcommsHandlerConfig(::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 pAcommsHandlerConfig_DriverFailureApproach DriverFailureApproach;
  typedef pAcommsHandlerConfig_MOOSVariables MOOSVariables;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kLoadSharedLibraryFieldNumber = 20,
    kLoadProtoFileFieldNumber = 21,
    kTranslatorEntryFieldNumber = 22,
    kMultiplexCreateMoosVarFieldNumber = 23,
    kDcclFrontseatForwardNameFieldNumber = 24,
    kListenDriverCfgFieldNumber = 31,
    kModemIdLookupPathFieldNumber = 101,
    kCommonFieldNumber = 1,
    kDriverCfgFieldNumber = 4,
    kMacCfgFieldNumber = 5,
    kQueueCfgFieldNumber = 6,
    kDcclCfgFieldNumber = 7,
    kRouteCfgFieldNumber = 8,
    kMoosVarFieldNumber = 10,
    kDriverFailureApproachFieldNumber = 32,
    kModemIdFieldNumber = 2,
  };
  // repeated string load_shared_library = 20 [(.goby.field) = {
  int load_shared_library_size() const;
  private:
  int _internal_load_shared_library_size() const;
  public:
  void clear_load_shared_library();
  const std::string& load_shared_library(int index) const;
  std::string* mutable_load_shared_library(int index);
  void set_load_shared_library(int index, const std::string& value);
  void set_load_shared_library(int index, std::string&& value);
  void set_load_shared_library(int index, const char* value);
  void set_load_shared_library(int index, const char* value, size_t size);
  std::string* add_load_shared_library();
  void add_load_shared_library(const std::string& value);
  void add_load_shared_library(std::string&& value);
  void add_load_shared_library(const char* value);
  void add_load_shared_library(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& load_shared_library() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_load_shared_library();
  private:
  const std::string& _internal_load_shared_library(int index) const;
  std::string* _internal_add_load_shared_library();
  public:
 
  // repeated string load_proto_file = 21 [(.goby.field) = {
  int load_proto_file_size() const;
  private:
  int _internal_load_proto_file_size() const;
  public:
  void clear_load_proto_file();
  const std::string& load_proto_file(int index) const;
  std::string* mutable_load_proto_file(int index);
  void set_load_proto_file(int index, const std::string& value);
  void set_load_proto_file(int index, std::string&& value);
  void set_load_proto_file(int index, const char* value);
  void set_load_proto_file(int index, const char* value, size_t size);
  std::string* add_load_proto_file();
  void add_load_proto_file(const std::string& value);
  void add_load_proto_file(std::string&& value);
  void add_load_proto_file(const char* value);
  void add_load_proto_file(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& load_proto_file() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_load_proto_file();
  private:
  const std::string& _internal_load_proto_file(int index) const;
  std::string* _internal_add_load_proto_file();
  public:
 
  // repeated .goby.moos.protobuf.TranslatorEntry translator_entry = 22 [(.goby.field) = {
  int translator_entry_size() const;
  private:
  int _internal_translator_entry_size() const;
  public:
  void clear_translator_entry();
  ::goby::moos::protobuf::TranslatorEntry* mutable_translator_entry(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >*
      mutable_translator_entry();
  private:
  const ::goby::moos::protobuf::TranslatorEntry& _internal_translator_entry(int index) const;
  ::goby::moos::protobuf::TranslatorEntry* _internal_add_translator_entry();
  public:
  const ::goby::moos::protobuf::TranslatorEntry& translator_entry(int index) const;
  ::goby::moos::protobuf::TranslatorEntry* add_translator_entry();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >&
      translator_entry() const;
 
  // repeated string multiplex_create_moos_var = 23 [(.goby.field) = {
  int multiplex_create_moos_var_size() const;
  private:
  int _internal_multiplex_create_moos_var_size() const;
  public:
  void clear_multiplex_create_moos_var();
  const std::string& multiplex_create_moos_var(int index) const;
  std::string* mutable_multiplex_create_moos_var(int index);
  void set_multiplex_create_moos_var(int index, const std::string& value);
  void set_multiplex_create_moos_var(int index, std::string&& value);
  void set_multiplex_create_moos_var(int index, const char* value);
  void set_multiplex_create_moos_var(int index, const char* value, size_t size);
  std::string* add_multiplex_create_moos_var();
  void add_multiplex_create_moos_var(const std::string& value);
  void add_multiplex_create_moos_var(std::string&& value);
  void add_multiplex_create_moos_var(const char* value);
  void add_multiplex_create_moos_var(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& multiplex_create_moos_var() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_multiplex_create_moos_var();
  private:
  const std::string& _internal_multiplex_create_moos_var(int index) const;
  std::string* _internal_add_multiplex_create_moos_var();
  public:
 
  // repeated string dccl_frontseat_forward_name = 24 [(.goby.field) = {
  int dccl_frontseat_forward_name_size() const;
  private:
  int _internal_dccl_frontseat_forward_name_size() const;
  public:
  void clear_dccl_frontseat_forward_name();
  const std::string& dccl_frontseat_forward_name(int index) const;
  std::string* mutable_dccl_frontseat_forward_name(int index);
  void set_dccl_frontseat_forward_name(int index, const std::string& value);
  void set_dccl_frontseat_forward_name(int index, std::string&& value);
  void set_dccl_frontseat_forward_name(int index, const char* value);
  void set_dccl_frontseat_forward_name(int index, const char* value, size_t size);
  std::string* add_dccl_frontseat_forward_name();
  void add_dccl_frontseat_forward_name(const std::string& value);
  void add_dccl_frontseat_forward_name(std::string&& value);
  void add_dccl_frontseat_forward_name(const char* value);
  void add_dccl_frontseat_forward_name(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dccl_frontseat_forward_name() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dccl_frontseat_forward_name();
  private:
  const std::string& _internal_dccl_frontseat_forward_name(int index) const;
  std::string* _internal_add_dccl_frontseat_forward_name();
  public:
 
  // repeated .goby.acomms.protobuf.DriverConfig listen_driver_cfg = 31 [(.goby.field) = {
  int listen_driver_cfg_size() const;
  private:
  int _internal_listen_driver_cfg_size() const;
  public:
  void clear_listen_driver_cfg();
  ::goby::acomms::protobuf::DriverConfig* mutable_listen_driver_cfg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >*
      mutable_listen_driver_cfg();
  private:
  const ::goby::acomms::protobuf::DriverConfig& _internal_listen_driver_cfg(int index) const;
  ::goby::acomms::protobuf::DriverConfig* _internal_add_listen_driver_cfg();
  public:
  const ::goby::acomms::protobuf::DriverConfig& listen_driver_cfg(int index) const;
  ::goby::acomms::protobuf::DriverConfig* add_listen_driver_cfg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >&
      listen_driver_cfg() const;
 
  // optional string modem_id_lookup_path = 101 [(.goby.field) = {
  bool has_modem_id_lookup_path() const;
  private:
  bool _internal_has_modem_id_lookup_path() const;
  public:
  void clear_modem_id_lookup_path();
  const std::string& modem_id_lookup_path() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_modem_id_lookup_path(ArgT0&& arg0, ArgT... args);
  std::string* mutable_modem_id_lookup_path();
  PROTOBUF_NODISCARD std::string* release_modem_id_lookup_path();
  void set_allocated_modem_id_lookup_path(std::string* modem_id_lookup_path);
  private:
  const std::string& _internal_modem_id_lookup_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_modem_id_lookup_path(const std::string& value);
  std::string* _internal_mutable_modem_id_lookup_path();
  public:
 
  // optional .goby.moos.protobuf.GobyMOOSAppConfig common = 1 [(.goby.field) = {
  bool has_common() const;
  private:
  bool _internal_has_common() const;
  public:
  void clear_common();
  const ::goby::moos::protobuf::GobyMOOSAppConfig& common() const;
  PROTOBUF_NODISCARD ::goby::moos::protobuf::GobyMOOSAppConfig* release_common();
  ::goby::moos::protobuf::GobyMOOSAppConfig* mutable_common();
  void set_allocated_common(::goby::moos::protobuf::GobyMOOSAppConfig* common);
  private:
  const ::goby::moos::protobuf::GobyMOOSAppConfig& _internal_common() const;
  ::goby::moos::protobuf::GobyMOOSAppConfig* _internal_mutable_common();
  public:
  void unsafe_arena_set_allocated_common(
      ::goby::moos::protobuf::GobyMOOSAppConfig* common);
  ::goby::moos::protobuf::GobyMOOSAppConfig* unsafe_arena_release_common();
 
  // optional .goby.acomms.protobuf.DriverConfig driver_cfg = 4 [(.goby.field) = {
  bool has_driver_cfg() const;
  private:
  bool _internal_has_driver_cfg() const;
  public:
  void clear_driver_cfg();
  const ::goby::acomms::protobuf::DriverConfig& driver_cfg() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::DriverConfig* release_driver_cfg();
  ::goby::acomms::protobuf::DriverConfig* mutable_driver_cfg();
  void set_allocated_driver_cfg(::goby::acomms::protobuf::DriverConfig* driver_cfg);
  private:
  const ::goby::acomms::protobuf::DriverConfig& _internal_driver_cfg() const;
  ::goby::acomms::protobuf::DriverConfig* _internal_mutable_driver_cfg();
  public:
  void unsafe_arena_set_allocated_driver_cfg(
      ::goby::acomms::protobuf::DriverConfig* driver_cfg);
  ::goby::acomms::protobuf::DriverConfig* unsafe_arena_release_driver_cfg();
 
  // optional .goby.acomms.protobuf.MACConfig mac_cfg = 5 [(.goby.field) = {
  bool has_mac_cfg() const;
  private:
  bool _internal_has_mac_cfg() const;
  public:
  void clear_mac_cfg();
  const ::goby::acomms::protobuf::MACConfig& mac_cfg() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::MACConfig* release_mac_cfg();
  ::goby::acomms::protobuf::MACConfig* mutable_mac_cfg();
  void set_allocated_mac_cfg(::goby::acomms::protobuf::MACConfig* mac_cfg);
  private:
  const ::goby::acomms::protobuf::MACConfig& _internal_mac_cfg() const;
  ::goby::acomms::protobuf::MACConfig* _internal_mutable_mac_cfg();
  public:
  void unsafe_arena_set_allocated_mac_cfg(
      ::goby::acomms::protobuf::MACConfig* mac_cfg);
  ::goby::acomms::protobuf::MACConfig* unsafe_arena_release_mac_cfg();
 
  // optional .goby.acomms.protobuf.QueueManagerConfig queue_cfg = 6 [(.goby.field) = {
  bool has_queue_cfg() const;
  private:
  bool _internal_has_queue_cfg() const;
  public:
  void clear_queue_cfg();
  const ::goby::acomms::protobuf::QueueManagerConfig& queue_cfg() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::QueueManagerConfig* release_queue_cfg();
  ::goby::acomms::protobuf::QueueManagerConfig* mutable_queue_cfg();
  void set_allocated_queue_cfg(::goby::acomms::protobuf::QueueManagerConfig* queue_cfg);
  private:
  const ::goby::acomms::protobuf::QueueManagerConfig& _internal_queue_cfg() const;
  ::goby::acomms::protobuf::QueueManagerConfig* _internal_mutable_queue_cfg();
  public:
  void unsafe_arena_set_allocated_queue_cfg(
      ::goby::acomms::protobuf::QueueManagerConfig* queue_cfg);
  ::goby::acomms::protobuf::QueueManagerConfig* unsafe_arena_release_queue_cfg();
 
  // optional .goby.acomms.protobuf.DCCLConfig dccl_cfg = 7 [(.goby.field) = {
  bool has_dccl_cfg() const;
  private:
  bool _internal_has_dccl_cfg() const;
  public:
  void clear_dccl_cfg();
  const ::goby::acomms::protobuf::DCCLConfig& dccl_cfg() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::DCCLConfig* release_dccl_cfg();
  ::goby::acomms::protobuf::DCCLConfig* mutable_dccl_cfg();
  void set_allocated_dccl_cfg(::goby::acomms::protobuf::DCCLConfig* dccl_cfg);
  private:
  const ::goby::acomms::protobuf::DCCLConfig& _internal_dccl_cfg() const;
  ::goby::acomms::protobuf::DCCLConfig* _internal_mutable_dccl_cfg();
  public:
  void unsafe_arena_set_allocated_dccl_cfg(
      ::goby::acomms::protobuf::DCCLConfig* dccl_cfg);
  ::goby::acomms::protobuf::DCCLConfig* unsafe_arena_release_dccl_cfg();
 
  // optional .goby.acomms.protobuf.RouteManagerConfig route_cfg = 8 [(.goby.field) = {
  bool has_route_cfg() const;
  private:
  bool _internal_has_route_cfg() const;
  public:
  void clear_route_cfg();
  const ::goby::acomms::protobuf::RouteManagerConfig& route_cfg() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::RouteManagerConfig* release_route_cfg();
  ::goby::acomms::protobuf::RouteManagerConfig* mutable_route_cfg();
  void set_allocated_route_cfg(::goby::acomms::protobuf::RouteManagerConfig* route_cfg);
  private:
  const ::goby::acomms::protobuf::RouteManagerConfig& _internal_route_cfg() const;
  ::goby::acomms::protobuf::RouteManagerConfig* _internal_mutable_route_cfg();
  public:
  void unsafe_arena_set_allocated_route_cfg(
      ::goby::acomms::protobuf::RouteManagerConfig* route_cfg);
  ::goby::acomms::protobuf::RouteManagerConfig* unsafe_arena_release_route_cfg();
 
  // optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables moos_var = 10;
  bool has_moos_var() const;
  private:
  bool _internal_has_moos_var() const;
  public:
  void clear_moos_var();
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables& moos_var() const;
  PROTOBUF_NODISCARD ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* release_moos_var();
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* mutable_moos_var();
  void set_allocated_moos_var(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* moos_var);
  private:
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables& _internal_moos_var() const;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* _internal_mutable_moos_var();
  public:
  void unsafe_arena_set_allocated_moos_var(
      ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* moos_var);
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* unsafe_arena_release_moos_var();
 
  // optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach driver_failure_approach = 32 [(.goby.field) = {
  bool has_driver_failure_approach() const;
  private:
  bool _internal_has_driver_failure_approach() const;
  public:
  void clear_driver_failure_approach();
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach& driver_failure_approach() const;
  PROTOBUF_NODISCARD ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* release_driver_failure_approach();
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* mutable_driver_failure_approach();
  void set_allocated_driver_failure_approach(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach);
  private:
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach& _internal_driver_failure_approach() const;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* _internal_mutable_driver_failure_approach();
  public:
  void unsafe_arena_set_allocated_driver_failure_approach(
      ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach);
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* unsafe_arena_release_driver_failure_approach();
 
  // required int32 modem_id = 2 [(.goby.field) = {
  bool has_modem_id() const;
  private:
  bool _internal_has_modem_id() const;
  public:
  void clear_modem_id();
  int32_t modem_id() const;
  void set_modem_id(int32_t value);
  private:
  int32_t _internal_modem_id() const;
  void _internal_set_modem_id(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.apps.moos.protobuf.pAcommsHandlerConfig)
 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_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> load_shared_library_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> load_proto_file_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry > translator_entry_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> multiplex_create_moos_var_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dccl_frontseat_forward_name_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig > listen_driver_cfg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modem_id_lookup_path_;
    ::goby::moos::protobuf::GobyMOOSAppConfig* common_;
    ::goby::acomms::protobuf::DriverConfig* driver_cfg_;
    ::goby::acomms::protobuf::MACConfig* mac_cfg_;
    ::goby::acomms::protobuf::QueueManagerConfig* queue_cfg_;
    ::goby::acomms::protobuf::DCCLConfig* dccl_cfg_;
    ::goby::acomms::protobuf::RouteManagerConfig* route_cfg_;
    ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* moos_var_;
    ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach_;
    int32_t modem_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// pAcommsHandlerConfig_DriverFailureApproach
 
// optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.DriverFailureTechnique technique = 1 [default = CONTINUALLY_RESTART_DRIVER];
inline bool pAcommsHandlerConfig_DriverFailureApproach::_internal_has_technique() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_DriverFailureApproach::has_technique() const {
  return _internal_has_technique();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::clear_technique() {
  _impl_.technique_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach::_internal_technique() const {
  return static_cast< ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique >(_impl_.technique_);
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique pAcommsHandlerConfig_DriverFailureApproach::technique() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.technique)
  return _internal_technique();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::_internal_set_technique(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value) {
  assert(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.technique_ = value;
}
inline void pAcommsHandlerConfig_DriverFailureApproach::set_technique(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique value) {
  _internal_set_technique(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.technique)
}
 
// optional int32 driver_backoff_sec = 2 [default = 60, (.goby.field) = {
inline bool pAcommsHandlerConfig_DriverFailureApproach::_internal_has_driver_backoff_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_DriverFailureApproach::has_driver_backoff_sec() const {
  return _internal_has_driver_backoff_sec();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::clear_driver_backoff_sec() {
  _impl_.driver_backoff_sec_ = 60;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t pAcommsHandlerConfig_DriverFailureApproach::_internal_driver_backoff_sec() const {
  return _impl_.driver_backoff_sec_;
}
inline int32_t pAcommsHandlerConfig_DriverFailureApproach::driver_backoff_sec() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.driver_backoff_sec)
  return _internal_driver_backoff_sec();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::_internal_set_driver_backoff_sec(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.driver_backoff_sec_ = value;
}
inline void pAcommsHandlerConfig_DriverFailureApproach::set_driver_backoff_sec(int32_t value) {
  _internal_set_driver_backoff_sec(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.driver_backoff_sec)
}
 
// optional int32 new_driver_backoff_sec = 3 [default = 5, (.goby.field) = {
inline bool pAcommsHandlerConfig_DriverFailureApproach::_internal_has_new_driver_backoff_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_DriverFailureApproach::has_new_driver_backoff_sec() const {
  return _internal_has_new_driver_backoff_sec();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::clear_new_driver_backoff_sec() {
  _impl_.new_driver_backoff_sec_ = 5;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t pAcommsHandlerConfig_DriverFailureApproach::_internal_new_driver_backoff_sec() const {
  return _impl_.new_driver_backoff_sec_;
}
inline int32_t pAcommsHandlerConfig_DriverFailureApproach::new_driver_backoff_sec() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.new_driver_backoff_sec)
  return _internal_new_driver_backoff_sec();
}
inline void pAcommsHandlerConfig_DriverFailureApproach::_internal_set_new_driver_backoff_sec(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.new_driver_backoff_sec_ = value;
}
inline void pAcommsHandlerConfig_DriverFailureApproach::set_new_driver_backoff_sec(int32_t value) {
  _internal_set_new_driver_backoff_sec(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach.new_driver_backoff_sec)
}
 
// -------------------------------------------------------------------
 
// pAcommsHandlerConfig_MOOSVariables
 
// optional string prefix = 1 [default = "ACOMMS_", (.goby.field) = {
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_prefix() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_prefix() const {
  return _internal_has_prefix();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_prefix() {
  _impl_.prefix_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_prefix_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::prefix() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.prefix)
  if (_impl_.prefix_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_prefix_.get();
  return _internal_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_prefix(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.prefix)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_prefix() {
  std::string* _s = _internal_mutable_prefix();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.prefix)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_prefix() const {
  return _impl_.prefix_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_prefix(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.prefix_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_prefix() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.prefix_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_prefix_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_prefix() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.prefix)
  if (!_internal_has_prefix()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.prefix_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_prefix(std::string* prefix) {
  if (prefix != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.prefix_.SetAllocated(prefix, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.prefix)
}
 
// optional string driver_raw_in = 10 [default = "NMEA_IN"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_raw_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_in() const {
  return _internal_has_driver_raw_in();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_in() {
  _impl_.driver_raw_in_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_in_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_in() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
  if (_impl_.driver_raw_in_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_raw_in_.get();
  return _internal_driver_raw_in();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_in(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.driver_raw_in_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_in() {
  std::string* _s = _internal_mutable_driver_raw_in();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_raw_in() const {
  return _impl_.driver_raw_in_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_raw_in(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.driver_raw_in_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_raw_in() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.driver_raw_in_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_in_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_in() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
  if (!_internal_has_driver_raw_in()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.driver_raw_in_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_in(std::string* driver_raw_in) {
  if (driver_raw_in != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.driver_raw_in_.SetAllocated(driver_raw_in, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_in)
}
 
// optional string driver_raw_out = 11 [default = "NMEA_OUT"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_raw_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_out() const {
  return _internal_has_driver_raw_out();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_out() {
  _impl_.driver_raw_out_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_out_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_out() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
  if (_impl_.driver_raw_out_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_raw_out_.get();
  return _internal_driver_raw_out();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_out(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.driver_raw_out_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_out() {
  std::string* _s = _internal_mutable_driver_raw_out();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_raw_out() const {
  return _impl_.driver_raw_out_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_raw_out(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.driver_raw_out_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_raw_out() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.driver_raw_out_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_out_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_out() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
  if (!_internal_has_driver_raw_out()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.driver_raw_out_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_out(std::string* driver_raw_out) {
  if (driver_raw_out != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.driver_raw_out_.SetAllocated(driver_raw_out, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_out)
}
 
// optional string driver_raw_msg_in = 12 [default = "RAW_INCOMING"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_raw_msg_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_msg_in() const {
  return _internal_has_driver_raw_msg_in();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_msg_in() {
  _impl_.driver_raw_msg_in_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_in_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_msg_in() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
  if (_impl_.driver_raw_msg_in_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_in_.get();
  return _internal_driver_raw_msg_in();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_in(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.driver_raw_msg_in_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_msg_in() {
  std::string* _s = _internal_mutable_driver_raw_msg_in();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_raw_msg_in() const {
  return _impl_.driver_raw_msg_in_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_raw_msg_in(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.driver_raw_msg_in_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_raw_msg_in() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.driver_raw_msg_in_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_in_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_msg_in() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
  if (!_internal_has_driver_raw_msg_in()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.driver_raw_msg_in_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_msg_in(std::string* driver_raw_msg_in) {
  if (driver_raw_msg_in != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.driver_raw_msg_in_.SetAllocated(driver_raw_msg_in, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_in)
}
 
// optional string driver_raw_msg_out = 13 [default = "RAW_OUTGOING"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_raw_msg_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_raw_msg_out() const {
  return _internal_has_driver_raw_msg_out();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_raw_msg_out() {
  _impl_.driver_raw_msg_out_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_out_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_raw_msg_out() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
  if (_impl_.driver_raw_msg_out_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_out_.get();
  return _internal_driver_raw_msg_out();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_raw_msg_out(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.driver_raw_msg_out_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_raw_msg_out() {
  std::string* _s = _internal_mutable_driver_raw_msg_out();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_raw_msg_out() const {
  return _impl_.driver_raw_msg_out_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_raw_msg_out(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.driver_raw_msg_out_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_raw_msg_out() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.driver_raw_msg_out_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_raw_msg_out_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_raw_msg_out() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
  if (!_internal_has_driver_raw_msg_out()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.driver_raw_msg_out_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_raw_msg_out(std::string* driver_raw_msg_out) {
  if (driver_raw_msg_out != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.driver_raw_msg_out_.SetAllocated(driver_raw_msg_out, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_raw_msg_out)
}
 
// optional string driver_receive = 14 [default = "MODEM_RECEIVE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_receive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_receive() const {
  return _internal_has_driver_receive();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_receive() {
  _impl_.driver_receive_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_receive_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_receive() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_receive)
  if (_impl_.driver_receive_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_receive_.get();
  return _internal_driver_receive();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_receive(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.driver_receive_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_receive)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_receive() {
  std::string* _s = _internal_mutable_driver_receive();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_receive)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_receive() const {
  return _impl_.driver_receive_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_receive(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.driver_receive_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_receive() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.driver_receive_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_receive_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_receive() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_receive)
  if (!_internal_has_driver_receive()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.driver_receive_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_receive(std::string* driver_receive) {
  if (driver_receive != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.driver_receive_.SetAllocated(driver_receive, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_receive)
}
 
// optional string driver_transmit = 15 [default = "MODEM_TRANSMIT"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_transmit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_transmit() const {
  return _internal_has_driver_transmit();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_transmit() {
  _impl_.driver_transmit_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_transmit_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_transmit() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_transmit)
  if (_impl_.driver_transmit_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_transmit_.get();
  return _internal_driver_transmit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_transmit(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.driver_transmit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_transmit)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_transmit() {
  std::string* _s = _internal_mutable_driver_transmit();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_transmit)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_transmit() const {
  return _impl_.driver_transmit_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_transmit(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.driver_transmit_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_transmit() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.driver_transmit_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_transmit_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_transmit() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_transmit)
  if (!_internal_has_driver_transmit()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.driver_transmit_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_transmit(std::string* driver_transmit) {
  if (driver_transmit != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.driver_transmit_.SetAllocated(driver_transmit, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_transmit)
}
 
// optional string driver_cfg_update = 16 [default = "DRIVER_CONFIG_UPDATE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_cfg_update() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_cfg_update() const {
  return _internal_has_driver_cfg_update();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_cfg_update() {
  _impl_.driver_cfg_update_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_cfg_update_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_cfg_update() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
  if (_impl_.driver_cfg_update_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_cfg_update_.get();
  return _internal_driver_cfg_update();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_cfg_update(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.driver_cfg_update_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_cfg_update() {
  std::string* _s = _internal_mutable_driver_cfg_update();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_cfg_update() const {
  return _impl_.driver_cfg_update_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_cfg_update(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.driver_cfg_update_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_cfg_update() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.driver_cfg_update_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_cfg_update_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_cfg_update() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
  if (!_internal_has_driver_cfg_update()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.driver_cfg_update_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_cfg_update(std::string* driver_cfg_update) {
  if (driver_cfg_update != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.driver_cfg_update_.SetAllocated(driver_cfg_update, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_cfg_update)
}
 
// optional string queue_receive = 100 [default = "QUEUE_RECEIVE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_receive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_receive() const {
  return _internal_has_queue_receive();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_receive() {
  _impl_.queue_receive_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_receive_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_receive() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_receive)
  if (_impl_.queue_receive_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_receive_.get();
  return _internal_queue_receive();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_receive(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.queue_receive_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_receive)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_receive() {
  std::string* _s = _internal_mutable_queue_receive();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_receive)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_receive() const {
  return _impl_.queue_receive_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_receive(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.queue_receive_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_receive() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.queue_receive_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_receive_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_receive() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_receive)
  if (!_internal_has_queue_receive()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.queue_receive_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_receive(std::string* queue_receive) {
  if (queue_receive != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.queue_receive_.SetAllocated(queue_receive, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_receive)
}
 
// optional string queue_transmit = 101 [default = "QUEUE_TRANSMIT"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_transmit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_transmit() const {
  return _internal_has_queue_transmit();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_transmit() {
  _impl_.queue_transmit_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_transmit_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_transmit() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_transmit)
  if (_impl_.queue_transmit_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_transmit_.get();
  return _internal_queue_transmit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_transmit(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.queue_transmit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_transmit)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_transmit() {
  std::string* _s = _internal_mutable_queue_transmit();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_transmit)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_transmit() const {
  return _impl_.queue_transmit_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_transmit(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.queue_transmit_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_transmit() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.queue_transmit_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_transmit_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_transmit() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_transmit)
  if (!_internal_has_queue_transmit()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.queue_transmit_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_transmit(std::string* queue_transmit) {
  if (queue_transmit != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.queue_transmit_.SetAllocated(queue_transmit, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_transmit)
}
 
// optional string queue_ack_transmission = 102 [default = "ACK"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_ack_transmission() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_ack_transmission() const {
  return _internal_has_queue_ack_transmission();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_ack_transmission() {
  _impl_.queue_ack_transmission_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_ack_transmission_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_ack_transmission() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
  if (_impl_.queue_ack_transmission_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_ack_transmission_.get();
  return _internal_queue_ack_transmission();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_transmission(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.queue_ack_transmission_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_ack_transmission() {
  std::string* _s = _internal_mutable_queue_ack_transmission();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_ack_transmission() const {
  return _impl_.queue_ack_transmission_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_ack_transmission(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.queue_ack_transmission_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_ack_transmission() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.queue_ack_transmission_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_ack_transmission_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_ack_transmission() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
  if (!_internal_has_queue_ack_transmission()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.queue_ack_transmission_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_ack_transmission(std::string* queue_ack_transmission) {
  if (queue_ack_transmission != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.queue_ack_transmission_.SetAllocated(queue_ack_transmission, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_transmission)
}
 
// optional string queue_ack_original_msg = 103 [default = "ACK_ORIGINAL"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_ack_original_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_ack_original_msg() const {
  return _internal_has_queue_ack_original_msg();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_ack_original_msg() {
  _impl_.queue_ack_original_msg_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_ack_original_msg_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_ack_original_msg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
  if (_impl_.queue_ack_original_msg_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_ack_original_msg_.get();
  return _internal_queue_ack_original_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_ack_original_msg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.queue_ack_original_msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_ack_original_msg() {
  std::string* _s = _internal_mutable_queue_ack_original_msg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_ack_original_msg() const {
  return _impl_.queue_ack_original_msg_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_ack_original_msg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.queue_ack_original_msg_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_ack_original_msg() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.queue_ack_original_msg_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_ack_original_msg_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_ack_original_msg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
  if (!_internal_has_queue_ack_original_msg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.queue_ack_original_msg_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_ack_original_msg(std::string* queue_ack_original_msg) {
  if (queue_ack_original_msg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.queue_ack_original_msg_.SetAllocated(queue_ack_original_msg, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_ack_original_msg)
}
 
// optional string queue_expire = 104 [default = "EXPIRE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_expire() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_expire() const {
  return _internal_has_queue_expire();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_expire() {
  _impl_.queue_expire_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_expire_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_expire() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_expire)
  if (_impl_.queue_expire_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_expire_.get();
  return _internal_queue_expire();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_expire(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00001000u;
 _impl_.queue_expire_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_expire)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_expire() {
  std::string* _s = _internal_mutable_queue_expire();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_expire)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_expire() const {
  return _impl_.queue_expire_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_expire(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.queue_expire_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_expire() {
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.queue_expire_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_expire_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_expire() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_expire)
  if (!_internal_has_queue_expire()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  auto* p = _impl_.queue_expire_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_expire(std::string* queue_expire) {
  if (queue_expire != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.queue_expire_.SetAllocated(queue_expire, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_expire)
}
 
// optional string queue_size = 105 [default = "QSIZE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_size() const {
  return _internal_has_queue_size();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_size() {
  _impl_.queue_size_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_size_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_size() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_size)
  if (_impl_.queue_size_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_size_.get();
  return _internal_queue_size();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_size(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00002000u;
 _impl_.queue_size_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_size)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_size() {
  std::string* _s = _internal_mutable_queue_size();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_size)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_size() const {
  return _impl_.queue_size_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_size(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.queue_size_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_size() {
  _impl_._has_bits_[0] |= 0x00002000u;
  return _impl_.queue_size_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_size_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_size() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_size)
  if (!_internal_has_queue_size()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00002000u;
  auto* p = _impl_.queue_size_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_size(std::string* queue_size) {
  if (queue_size != nullptr) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.queue_size_.SetAllocated(queue_size, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_size)
}
 
// optional string queue_flush = 106 [default = "FLUSH_QUEUE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_queue_flush() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_queue_flush() const {
  return _internal_has_queue_flush();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_queue_flush() {
  _impl_.queue_flush_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_flush_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::queue_flush() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_flush)
  if (_impl_.queue_flush_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_queue_flush_.get();
  return _internal_queue_flush();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_queue_flush(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00004000u;
 _impl_.queue_flush_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_flush)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_queue_flush() {
  std::string* _s = _internal_mutable_queue_flush();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_flush)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_queue_flush() const {
  return _impl_.queue_flush_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_queue_flush(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.queue_flush_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_queue_flush() {
  _impl_._has_bits_[0] |= 0x00004000u;
  return _impl_.queue_flush_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_queue_flush_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_queue_flush() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_flush)
  if (!_internal_has_queue_flush()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00004000u;
  auto* p = _impl_.queue_flush_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_queue_flush(std::string* queue_flush) {
  if (queue_flush != nullptr) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.queue_flush_.SetAllocated(queue_flush, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.queue_flush)
}
 
// optional string mac_cycle_update = 200 [default = "MAC_CYCLE_UPDATE"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_mac_cycle_update() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_cycle_update() const {
  return _internal_has_mac_cycle_update();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_cycle_update() {
  _impl_.mac_cycle_update_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_cycle_update_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::mac_cycle_update() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
  if (_impl_.mac_cycle_update_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_mac_cycle_update_.get();
  return _internal_mac_cycle_update();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_mac_cycle_update(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00008000u;
 _impl_.mac_cycle_update_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_cycle_update() {
  std::string* _s = _internal_mutable_mac_cycle_update();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_mac_cycle_update() const {
  return _impl_.mac_cycle_update_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_mac_cycle_update(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.mac_cycle_update_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_mac_cycle_update() {
  _impl_._has_bits_[0] |= 0x00008000u;
  return _impl_.mac_cycle_update_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_cycle_update_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_cycle_update() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
  if (!_internal_has_mac_cycle_update()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00008000u;
  auto* p = _impl_.mac_cycle_update_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_cycle_update(std::string* mac_cycle_update) {
  if (mac_cycle_update != nullptr) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.mac_cycle_update_.SetAllocated(mac_cycle_update, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_cycle_update)
}
 
// optional string mac_initiate_transmission = 201 [default = "MAC_INITIATE_TRANSMISSION"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_mac_initiate_transmission() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_initiate_transmission() const {
  return _internal_has_mac_initiate_transmission();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_initiate_transmission() {
  _impl_.mac_initiate_transmission_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_initiate_transmission_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::mac_initiate_transmission() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
  if (_impl_.mac_initiate_transmission_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_mac_initiate_transmission_.get();
  return _internal_mac_initiate_transmission();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_mac_initiate_transmission(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00010000u;
 _impl_.mac_initiate_transmission_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_initiate_transmission() {
  std::string* _s = _internal_mutable_mac_initiate_transmission();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_mac_initiate_transmission() const {
  return _impl_.mac_initiate_transmission_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_mac_initiate_transmission(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.mac_initiate_transmission_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_mac_initiate_transmission() {
  _impl_._has_bits_[0] |= 0x00010000u;
  return _impl_.mac_initiate_transmission_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_initiate_transmission_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_initiate_transmission() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
  if (!_internal_has_mac_initiate_transmission()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00010000u;
  auto* p = _impl_.mac_initiate_transmission_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_initiate_transmission(std::string* mac_initiate_transmission) {
  if (mac_initiate_transmission != nullptr) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.mac_initiate_transmission_.SetAllocated(mac_initiate_transmission, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_initiate_transmission)
}
 
// optional string mac_slot_start = 202 [default = "MAC_SLOT_START"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_mac_slot_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_mac_slot_start() const {
  return _internal_has_mac_slot_start();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_mac_slot_start() {
  _impl_.mac_slot_start_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_slot_start_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::mac_slot_start() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
  if (_impl_.mac_slot_start_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_mac_slot_start_.get();
  return _internal_mac_slot_start();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_mac_slot_start(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00020000u;
 _impl_.mac_slot_start_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_mac_slot_start() {
  std::string* _s = _internal_mutable_mac_slot_start();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_mac_slot_start() const {
  return _impl_.mac_slot_start_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_mac_slot_start(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.mac_slot_start_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_mac_slot_start() {
  _impl_._has_bits_[0] |= 0x00020000u;
  return _impl_.mac_slot_start_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_mac_slot_start_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_mac_slot_start() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
  if (!_internal_has_mac_slot_start()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00020000u;
  auto* p = _impl_.mac_slot_start_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_mac_slot_start(std::string* mac_slot_start) {
  if (mac_slot_start != nullptr) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.mac_slot_start_.SetAllocated(mac_slot_start, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.mac_slot_start)
}
 
// optional string config_file = 300 [default = "CONFIG"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_config_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_config_file() const {
  return _internal_has_config_file();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_config_file() {
  _impl_.config_file_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_config_file_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::config_file() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file)
  if (_impl_.config_file_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_config_file_.get();
  return _internal_config_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_config_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00040000u;
 _impl_.config_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_config_file() {
  std::string* _s = _internal_mutable_config_file();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_config_file() const {
  return _impl_.config_file_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_config_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.config_file_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_config_file() {
  _impl_._has_bits_[0] |= 0x00040000u;
  return _impl_.config_file_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_config_file_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_config_file() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file)
  if (!_internal_has_config_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00040000u;
  auto* p = _impl_.config_file_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_config_file(std::string* config_file) {
  if (config_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.config_file_.SetAllocated(config_file, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file)
}
 
// optional string config_file_request = 301 [default = "CONFIG_REQUEST"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_config_file_request() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_config_file_request() const {
  return _internal_has_config_file_request();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_config_file_request() {
  _impl_.config_file_request_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_config_file_request_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::config_file_request() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file_request)
  if (_impl_.config_file_request_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_config_file_request_.get();
  return _internal_config_file_request();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_config_file_request(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00080000u;
 _impl_.config_file_request_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file_request)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_config_file_request() {
  std::string* _s = _internal_mutable_config_file_request();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file_request)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_config_file_request() const {
  return _impl_.config_file_request_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_config_file_request(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.config_file_request_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_config_file_request() {
  _impl_._has_bits_[0] |= 0x00080000u;
  return _impl_.config_file_request_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_config_file_request_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_config_file_request() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file_request)
  if (!_internal_has_config_file_request()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00080000u;
  auto* p = _impl_.config_file_request_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_config_file_request(std::string* config_file_request) {
  if (config_file_request != nullptr) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.config_file_request_.SetAllocated(config_file_request, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.config_file_request)
}
 
// optional string driver_reset = 400 [default = "DRIVER_RESET"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_driver_reset() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_driver_reset() const {
  return _internal_has_driver_reset();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_driver_reset() {
  _impl_.driver_reset_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_reset_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::driver_reset() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_reset)
  if (_impl_.driver_reset_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_driver_reset_.get();
  return _internal_driver_reset();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_driver_reset(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00100000u;
 _impl_.driver_reset_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_reset)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_driver_reset() {
  std::string* _s = _internal_mutable_driver_reset();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_reset)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_driver_reset() const {
  return _impl_.driver_reset_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_driver_reset(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.driver_reset_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_driver_reset() {
  _impl_._has_bits_[0] |= 0x00100000u;
  return _impl_.driver_reset_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_driver_reset_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_driver_reset() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_reset)
  if (!_internal_has_driver_reset()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00100000u;
  auto* p = _impl_.driver_reset_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_driver_reset(std::string* driver_reset) {
  if (driver_reset != nullptr) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.driver_reset_.SetAllocated(driver_reset, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.driver_reset)
}
 
// optional string ifrontseat_data_out = 500 [default = "IFS_DATA_OUT"];
inline bool pAcommsHandlerConfig_MOOSVariables::_internal_has_ifrontseat_data_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig_MOOSVariables::has_ifrontseat_data_out() const {
  return _internal_has_ifrontseat_data_out();
}
inline void pAcommsHandlerConfig_MOOSVariables::clear_ifrontseat_data_out() {
  _impl_.ifrontseat_data_out_.ClearToDefault(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_ifrontseat_data_out_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::ifrontseat_data_out() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
  if (_impl_.ifrontseat_data_out_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_ifrontseat_data_out_.get();
  return _internal_ifrontseat_data_out();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig_MOOSVariables::set_ifrontseat_data_out(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00200000u;
 _impl_.ifrontseat_data_out_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::mutable_ifrontseat_data_out() {
  std::string* _s = _internal_mutable_ifrontseat_data_out();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
  return _s;
}
inline const std::string& pAcommsHandlerConfig_MOOSVariables::_internal_ifrontseat_data_out() const {
  return _impl_.ifrontseat_data_out_.Get();
}
inline void pAcommsHandlerConfig_MOOSVariables::_internal_set_ifrontseat_data_out(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.ifrontseat_data_out_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::_internal_mutable_ifrontseat_data_out() {
  _impl_._has_bits_[0] |= 0x00200000u;
  return _impl_.ifrontseat_data_out_.Mutable(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables::Impl_::_i_give_permission_to_break_this_code_default_ifrontseat_data_out_, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig_MOOSVariables::release_ifrontseat_data_out() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
  if (!_internal_has_ifrontseat_data_out()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00200000u;
  auto* p = _impl_.ifrontseat_data_out_.Release();
  return p;
}
inline void pAcommsHandlerConfig_MOOSVariables::set_allocated_ifrontseat_data_out(std::string* ifrontseat_data_out) {
  if (ifrontseat_data_out != nullptr) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.ifrontseat_data_out_.SetAllocated(ifrontseat_data_out, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables.ifrontseat_data_out)
}
 
// -------------------------------------------------------------------
 
// pAcommsHandlerConfig
 
// optional .goby.moos.protobuf.GobyMOOSAppConfig common = 1 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_common() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.common_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_common() const {
  return _internal_has_common();
}
inline const ::goby::moos::protobuf::GobyMOOSAppConfig& pAcommsHandlerConfig::_internal_common() const {
  const ::goby::moos::protobuf::GobyMOOSAppConfig* p = _impl_.common_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::moos::protobuf::GobyMOOSAppConfig&>(
      ::goby::moos::protobuf::_GobyMOOSAppConfig_default_instance_);
}
inline const ::goby::moos::protobuf::GobyMOOSAppConfig& pAcommsHandlerConfig::common() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.common)
  return _internal_common();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_common(
    ::goby::moos::protobuf::GobyMOOSAppConfig* common) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.common_);
  }
  _impl_.common_ = common;
  if (common) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.common)
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* pAcommsHandlerConfig::release_common() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::moos::protobuf::GobyMOOSAppConfig* temp = _impl_.common_;
  _impl_.common_ = 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::moos::protobuf::GobyMOOSAppConfig* pAcommsHandlerConfig::unsafe_arena_release_common() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.common)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::moos::protobuf::GobyMOOSAppConfig* temp = _impl_.common_;
  _impl_.common_ = nullptr;
  return temp;
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* pAcommsHandlerConfig::_internal_mutable_common() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.common_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::moos::protobuf::GobyMOOSAppConfig>(GetArenaForAllocation());
    _impl_.common_ = p;
  }
  return _impl_.common_;
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* pAcommsHandlerConfig::mutable_common() {
  ::goby::moos::protobuf::GobyMOOSAppConfig* _msg = _internal_mutable_common();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.common)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_common(::goby::moos::protobuf::GobyMOOSAppConfig* common) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.common_);
  }
  if (common) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common));
    if (message_arena != submessage_arena) {
      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, common, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.common_ = common;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.common)
}
 
// required int32 modem_id = 2 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_modem_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig::has_modem_id() const {
  return _internal_has_modem_id();
}
inline void pAcommsHandlerConfig::clear_modem_id() {
  _impl_.modem_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t pAcommsHandlerConfig::_internal_modem_id() const {
  return _impl_.modem_id_;
}
inline int32_t pAcommsHandlerConfig::modem_id() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id)
  return _internal_modem_id();
}
inline void pAcommsHandlerConfig::_internal_set_modem_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.modem_id_ = value;
}
inline void pAcommsHandlerConfig::set_modem_id(int32_t value) {
  _internal_set_modem_id(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id)
}
 
// optional .goby.acomms.protobuf.DriverConfig driver_cfg = 4 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_driver_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.driver_cfg_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_driver_cfg() const {
  return _internal_has_driver_cfg();
}
inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::_internal_driver_cfg() const {
  const ::goby::acomms::protobuf::DriverConfig* p = _impl_.driver_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::DriverConfig&>(
      ::goby::acomms::protobuf::_DriverConfig_default_instance_);
}
inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::driver_cfg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_cfg)
  return _internal_driver_cfg();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_driver_cfg(
    ::goby::acomms::protobuf::DriverConfig* driver_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.driver_cfg_);
  }
  _impl_.driver_cfg_ = driver_cfg;
  if (driver_cfg) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_cfg)
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::release_driver_cfg() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::protobuf::DriverConfig* temp = _impl_.driver_cfg_;
  _impl_.driver_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::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::unsafe_arena_release_driver_cfg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_cfg)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::protobuf::DriverConfig* temp = _impl_.driver_cfg_;
  _impl_.driver_cfg_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::_internal_mutable_driver_cfg() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.driver_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::DriverConfig>(GetArenaForAllocation());
    _impl_.driver_cfg_ = p;
  }
  return _impl_.driver_cfg_;
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::mutable_driver_cfg() {
  ::goby::acomms::protobuf::DriverConfig* _msg = _internal_mutable_driver_cfg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_cfg)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_driver_cfg(::goby::acomms::protobuf::DriverConfig* driver_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.driver_cfg_);
  }
  if (driver_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(driver_cfg));
    if (message_arena != submessage_arena) {
      driver_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, driver_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.driver_cfg_ = driver_cfg;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_cfg)
}
 
// repeated .goby.acomms.protobuf.DriverConfig listen_driver_cfg = 31 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_listen_driver_cfg_size() const {
  return _impl_.listen_driver_cfg_.size();
}
inline int pAcommsHandlerConfig::listen_driver_cfg_size() const {
  return _internal_listen_driver_cfg_size();
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::mutable_listen_driver_cfg(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.listen_driver_cfg)
  return _impl_.listen_driver_cfg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >*
pAcommsHandlerConfig::mutable_listen_driver_cfg() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.listen_driver_cfg)
  return &_impl_.listen_driver_cfg_;
}
inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::_internal_listen_driver_cfg(int index) const {
  return _impl_.listen_driver_cfg_.Get(index);
}
inline const ::goby::acomms::protobuf::DriverConfig& pAcommsHandlerConfig::listen_driver_cfg(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.listen_driver_cfg)
  return _internal_listen_driver_cfg(index);
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::_internal_add_listen_driver_cfg() {
  return _impl_.listen_driver_cfg_.Add();
}
inline ::goby::acomms::protobuf::DriverConfig* pAcommsHandlerConfig::add_listen_driver_cfg() {
  ::goby::acomms::protobuf::DriverConfig* _add = _internal_add_listen_driver_cfg();
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.listen_driver_cfg)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::DriverConfig >&
pAcommsHandlerConfig::listen_driver_cfg() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.listen_driver_cfg)
  return _impl_.listen_driver_cfg_;
}
 
// optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.DriverFailureApproach driver_failure_approach = 32 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_driver_failure_approach() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.driver_failure_approach_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_driver_failure_approach() const {
  return _internal_has_driver_failure_approach();
}
inline void pAcommsHandlerConfig::clear_driver_failure_approach() {
  if (_impl_.driver_failure_approach_ != nullptr) _impl_.driver_failure_approach_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach& pAcommsHandlerConfig::_internal_driver_failure_approach() const {
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* p = _impl_.driver_failure_approach_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach&>(
      ::goby::apps::moos::protobuf::_pAcommsHandlerConfig_DriverFailureApproach_default_instance_);
}
inline const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach& pAcommsHandlerConfig::driver_failure_approach() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_failure_approach)
  return _internal_driver_failure_approach();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_driver_failure_approach(
    ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.driver_failure_approach_);
  }
  _impl_.driver_failure_approach_ = driver_failure_approach;
  if (driver_failure_approach) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_failure_approach)
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::release_driver_failure_approach() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* temp = _impl_.driver_failure_approach_;
  _impl_.driver_failure_approach_ = 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::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::unsafe_arena_release_driver_failure_approach() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_failure_approach)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* temp = _impl_.driver_failure_approach_;
  _impl_.driver_failure_approach_ = nullptr;
  return temp;
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::_internal_mutable_driver_failure_approach() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.driver_failure_approach_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach>(GetArenaForAllocation());
    _impl_.driver_failure_approach_ = p;
  }
  return _impl_.driver_failure_approach_;
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* pAcommsHandlerConfig::mutable_driver_failure_approach() {
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* _msg = _internal_mutable_driver_failure_approach();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_failure_approach)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_driver_failure_approach(::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach* driver_failure_approach) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.driver_failure_approach_;
  }
  if (driver_failure_approach) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(driver_failure_approach);
    if (message_arena != submessage_arena) {
      driver_failure_approach = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, driver_failure_approach, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.driver_failure_approach_ = driver_failure_approach;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.driver_failure_approach)
}
 
// optional .goby.acomms.protobuf.MACConfig mac_cfg = 5 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_mac_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mac_cfg_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_mac_cfg() const {
  return _internal_has_mac_cfg();
}
inline const ::goby::acomms::protobuf::MACConfig& pAcommsHandlerConfig::_internal_mac_cfg() const {
  const ::goby::acomms::protobuf::MACConfig* p = _impl_.mac_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::MACConfig&>(
      ::goby::acomms::protobuf::_MACConfig_default_instance_);
}
inline const ::goby::acomms::protobuf::MACConfig& pAcommsHandlerConfig::mac_cfg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.mac_cfg)
  return _internal_mac_cfg();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_mac_cfg(
    ::goby::acomms::protobuf::MACConfig* mac_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mac_cfg_);
  }
  _impl_.mac_cfg_ = mac_cfg;
  if (mac_cfg) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.mac_cfg)
}
inline ::goby::acomms::protobuf::MACConfig* pAcommsHandlerConfig::release_mac_cfg() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::protobuf::MACConfig* temp = _impl_.mac_cfg_;
  _impl_.mac_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::acomms::protobuf::MACConfig* pAcommsHandlerConfig::unsafe_arena_release_mac_cfg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.mac_cfg)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::goby::acomms::protobuf::MACConfig* temp = _impl_.mac_cfg_;
  _impl_.mac_cfg_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::MACConfig* pAcommsHandlerConfig::_internal_mutable_mac_cfg() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.mac_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::MACConfig>(GetArenaForAllocation());
    _impl_.mac_cfg_ = p;
  }
  return _impl_.mac_cfg_;
}
inline ::goby::acomms::protobuf::MACConfig* pAcommsHandlerConfig::mutable_mac_cfg() {
  ::goby::acomms::protobuf::MACConfig* _msg = _internal_mutable_mac_cfg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.mac_cfg)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_mac_cfg(::goby::acomms::protobuf::MACConfig* mac_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mac_cfg_);
  }
  if (mac_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mac_cfg));
    if (message_arena != submessage_arena) {
      mac_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mac_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mac_cfg_ = mac_cfg;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.mac_cfg)
}
 
// optional .goby.acomms.protobuf.QueueManagerConfig queue_cfg = 6 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_queue_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.queue_cfg_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_queue_cfg() const {
  return _internal_has_queue_cfg();
}
inline const ::goby::acomms::protobuf::QueueManagerConfig& pAcommsHandlerConfig::_internal_queue_cfg() const {
  const ::goby::acomms::protobuf::QueueManagerConfig* p = _impl_.queue_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::QueueManagerConfig&>(
      ::goby::acomms::protobuf::_QueueManagerConfig_default_instance_);
}
inline const ::goby::acomms::protobuf::QueueManagerConfig& pAcommsHandlerConfig::queue_cfg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.queue_cfg)
  return _internal_queue_cfg();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_queue_cfg(
    ::goby::acomms::protobuf::QueueManagerConfig* queue_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.queue_cfg_);
  }
  _impl_.queue_cfg_ = queue_cfg;
  if (queue_cfg) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.queue_cfg)
}
inline ::goby::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::release_queue_cfg() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::protobuf::QueueManagerConfig* temp = _impl_.queue_cfg_;
  _impl_.queue_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::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::unsafe_arena_release_queue_cfg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.queue_cfg)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::acomms::protobuf::QueueManagerConfig* temp = _impl_.queue_cfg_;
  _impl_.queue_cfg_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::_internal_mutable_queue_cfg() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.queue_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::QueueManagerConfig>(GetArenaForAllocation());
    _impl_.queue_cfg_ = p;
  }
  return _impl_.queue_cfg_;
}
inline ::goby::acomms::protobuf::QueueManagerConfig* pAcommsHandlerConfig::mutable_queue_cfg() {
  ::goby::acomms::protobuf::QueueManagerConfig* _msg = _internal_mutable_queue_cfg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.queue_cfg)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_queue_cfg(::goby::acomms::protobuf::QueueManagerConfig* queue_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.queue_cfg_);
  }
  if (queue_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(queue_cfg));
    if (message_arena != submessage_arena) {
      queue_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, queue_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.queue_cfg_ = queue_cfg;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.queue_cfg)
}
 
// optional .goby.acomms.protobuf.DCCLConfig dccl_cfg = 7 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_dccl_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dccl_cfg_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_dccl_cfg() const {
  return _internal_has_dccl_cfg();
}
inline const ::goby::acomms::protobuf::DCCLConfig& pAcommsHandlerConfig::_internal_dccl_cfg() const {
  const ::goby::acomms::protobuf::DCCLConfig* p = _impl_.dccl_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::DCCLConfig&>(
      ::goby::acomms::protobuf::_DCCLConfig_default_instance_);
}
inline const ::goby::acomms::protobuf::DCCLConfig& pAcommsHandlerConfig::dccl_cfg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_cfg)
  return _internal_dccl_cfg();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_dccl_cfg(
    ::goby::acomms::protobuf::DCCLConfig* dccl_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dccl_cfg_);
  }
  _impl_.dccl_cfg_ = dccl_cfg;
  if (dccl_cfg) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_cfg)
}
inline ::goby::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::release_dccl_cfg() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::protobuf::DCCLConfig* temp = _impl_.dccl_cfg_;
  _impl_.dccl_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::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::unsafe_arena_release_dccl_cfg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_cfg)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::goby::acomms::protobuf::DCCLConfig* temp = _impl_.dccl_cfg_;
  _impl_.dccl_cfg_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::_internal_mutable_dccl_cfg() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.dccl_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::DCCLConfig>(GetArenaForAllocation());
    _impl_.dccl_cfg_ = p;
  }
  return _impl_.dccl_cfg_;
}
inline ::goby::acomms::protobuf::DCCLConfig* pAcommsHandlerConfig::mutable_dccl_cfg() {
  ::goby::acomms::protobuf::DCCLConfig* _msg = _internal_mutable_dccl_cfg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_cfg)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_dccl_cfg(::goby::acomms::protobuf::DCCLConfig* dccl_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dccl_cfg_);
  }
  if (dccl_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dccl_cfg));
    if (message_arena != submessage_arena) {
      dccl_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dccl_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.dccl_cfg_ = dccl_cfg;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_cfg)
}
 
// optional .goby.acomms.protobuf.RouteManagerConfig route_cfg = 8 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_route_cfg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.route_cfg_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_route_cfg() const {
  return _internal_has_route_cfg();
}
inline const ::goby::acomms::protobuf::RouteManagerConfig& pAcommsHandlerConfig::_internal_route_cfg() const {
  const ::goby::acomms::protobuf::RouteManagerConfig* p = _impl_.route_cfg_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::RouteManagerConfig&>(
      ::goby::acomms::protobuf::_RouteManagerConfig_default_instance_);
}
inline const ::goby::acomms::protobuf::RouteManagerConfig& pAcommsHandlerConfig::route_cfg() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.route_cfg)
  return _internal_route_cfg();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_route_cfg(
    ::goby::acomms::protobuf::RouteManagerConfig* route_cfg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.route_cfg_);
  }
  _impl_.route_cfg_ = route_cfg;
  if (route_cfg) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.route_cfg)
}
inline ::goby::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::release_route_cfg() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::acomms::protobuf::RouteManagerConfig* temp = _impl_.route_cfg_;
  _impl_.route_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::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::unsafe_arena_release_route_cfg() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.route_cfg)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::goby::acomms::protobuf::RouteManagerConfig* temp = _impl_.route_cfg_;
  _impl_.route_cfg_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::_internal_mutable_route_cfg() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.route_cfg_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::RouteManagerConfig>(GetArenaForAllocation());
    _impl_.route_cfg_ = p;
  }
  return _impl_.route_cfg_;
}
inline ::goby::acomms::protobuf::RouteManagerConfig* pAcommsHandlerConfig::mutable_route_cfg() {
  ::goby::acomms::protobuf::RouteManagerConfig* _msg = _internal_mutable_route_cfg();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.route_cfg)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_route_cfg(::goby::acomms::protobuf::RouteManagerConfig* route_cfg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.route_cfg_);
  }
  if (route_cfg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(route_cfg));
    if (message_arena != submessage_arena) {
      route_cfg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, route_cfg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.route_cfg_ = route_cfg;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.route_cfg)
}
 
// optional .goby.apps.moos.protobuf.pAcommsHandlerConfig.MOOSVariables moos_var = 10;
inline bool pAcommsHandlerConfig::_internal_has_moos_var() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.moos_var_ != nullptr);
  return value;
}
inline bool pAcommsHandlerConfig::has_moos_var() const {
  return _internal_has_moos_var();
}
inline void pAcommsHandlerConfig::clear_moos_var() {
  if (_impl_.moos_var_ != nullptr) _impl_.moos_var_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables& pAcommsHandlerConfig::_internal_moos_var() const {
  const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* p = _impl_.moos_var_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables&>(
      ::goby::apps::moos::protobuf::_pAcommsHandlerConfig_MOOSVariables_default_instance_);
}
inline const ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables& pAcommsHandlerConfig::moos_var() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.moos_var)
  return _internal_moos_var();
}
inline void pAcommsHandlerConfig::unsafe_arena_set_allocated_moos_var(
    ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* moos_var) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.moos_var_);
  }
  _impl_.moos_var_ = moos_var;
  if (moos_var) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.moos_var)
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::release_moos_var() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* temp = _impl_.moos_var_;
  _impl_.moos_var_ = 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::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::unsafe_arena_release_moos_var() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.moos_var)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* temp = _impl_.moos_var_;
  _impl_.moos_var_ = nullptr;
  return temp;
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::_internal_mutable_moos_var() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.moos_var_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables>(GetArenaForAllocation());
    _impl_.moos_var_ = p;
  }
  return _impl_.moos_var_;
}
inline ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* pAcommsHandlerConfig::mutable_moos_var() {
  ::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* _msg = _internal_mutable_moos_var();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.moos_var)
  return _msg;
}
inline void pAcommsHandlerConfig::set_allocated_moos_var(::goby::apps::moos::protobuf::pAcommsHandlerConfig_MOOSVariables* moos_var) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.moos_var_;
  }
  if (moos_var) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(moos_var);
    if (message_arena != submessage_arena) {
      moos_var = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, moos_var, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.moos_var_ = moos_var;
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.moos_var)
}
 
// repeated string load_shared_library = 20 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_load_shared_library_size() const {
  return _impl_.load_shared_library_.size();
}
inline int pAcommsHandlerConfig::load_shared_library_size() const {
  return _internal_load_shared_library_size();
}
inline void pAcommsHandlerConfig::clear_load_shared_library() {
  _impl_.load_shared_library_.Clear();
}
inline std::string* pAcommsHandlerConfig::add_load_shared_library() {
  std::string* _s = _internal_add_load_shared_library();
  // @@protoc_insertion_point(field_add_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
  return _s;
}
inline const std::string& pAcommsHandlerConfig::_internal_load_shared_library(int index) const {
  return _impl_.load_shared_library_.Get(index);
}
inline const std::string& pAcommsHandlerConfig::load_shared_library(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
  return _internal_load_shared_library(index);
}
inline std::string* pAcommsHandlerConfig::mutable_load_shared_library(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
  return _impl_.load_shared_library_.Mutable(index);
}
inline void pAcommsHandlerConfig::set_load_shared_library(int index, const std::string& value) {
  _impl_.load_shared_library_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::set_load_shared_library(int index, std::string&& value) {
  _impl_.load_shared_library_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::set_load_shared_library(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.load_shared_library_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::set_load_shared_library(int index, const char* value, size_t size) {
  _impl_.load_shared_library_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline std::string* pAcommsHandlerConfig::_internal_add_load_shared_library() {
  return _impl_.load_shared_library_.Add();
}
inline void pAcommsHandlerConfig::add_load_shared_library(const std::string& value) {
  _impl_.load_shared_library_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::add_load_shared_library(std::string&& value) {
  _impl_.load_shared_library_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::add_load_shared_library(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.load_shared_library_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline void pAcommsHandlerConfig::add_load_shared_library(const char* value, size_t size) {
  _impl_.load_shared_library_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
pAcommsHandlerConfig::load_shared_library() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
  return _impl_.load_shared_library_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
pAcommsHandlerConfig::mutable_load_shared_library() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_shared_library)
  return &_impl_.load_shared_library_;
}
 
// repeated string load_proto_file = 21 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_load_proto_file_size() const {
  return _impl_.load_proto_file_.size();
}
inline int pAcommsHandlerConfig::load_proto_file_size() const {
  return _internal_load_proto_file_size();
}
inline void pAcommsHandlerConfig::clear_load_proto_file() {
  _impl_.load_proto_file_.Clear();
}
inline std::string* pAcommsHandlerConfig::add_load_proto_file() {
  std::string* _s = _internal_add_load_proto_file();
  // @@protoc_insertion_point(field_add_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
  return _s;
}
inline const std::string& pAcommsHandlerConfig::_internal_load_proto_file(int index) const {
  return _impl_.load_proto_file_.Get(index);
}
inline const std::string& pAcommsHandlerConfig::load_proto_file(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
  return _internal_load_proto_file(index);
}
inline std::string* pAcommsHandlerConfig::mutable_load_proto_file(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
  return _impl_.load_proto_file_.Mutable(index);
}
inline void pAcommsHandlerConfig::set_load_proto_file(int index, const std::string& value) {
  _impl_.load_proto_file_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::set_load_proto_file(int index, std::string&& value) {
  _impl_.load_proto_file_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::set_load_proto_file(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.load_proto_file_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::set_load_proto_file(int index, const char* value, size_t size) {
  _impl_.load_proto_file_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline std::string* pAcommsHandlerConfig::_internal_add_load_proto_file() {
  return _impl_.load_proto_file_.Add();
}
inline void pAcommsHandlerConfig::add_load_proto_file(const std::string& value) {
  _impl_.load_proto_file_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::add_load_proto_file(std::string&& value) {
  _impl_.load_proto_file_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::add_load_proto_file(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.load_proto_file_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline void pAcommsHandlerConfig::add_load_proto_file(const char* value, size_t size) {
  _impl_.load_proto_file_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
pAcommsHandlerConfig::load_proto_file() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
  return _impl_.load_proto_file_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
pAcommsHandlerConfig::mutable_load_proto_file() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.load_proto_file)
  return &_impl_.load_proto_file_;
}
 
// repeated .goby.moos.protobuf.TranslatorEntry translator_entry = 22 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_translator_entry_size() const {
  return _impl_.translator_entry_.size();
}
inline int pAcommsHandlerConfig::translator_entry_size() const {
  return _internal_translator_entry_size();
}
inline ::goby::moos::protobuf::TranslatorEntry* pAcommsHandlerConfig::mutable_translator_entry(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.translator_entry)
  return _impl_.translator_entry_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >*
pAcommsHandlerConfig::mutable_translator_entry() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.translator_entry)
  return &_impl_.translator_entry_;
}
inline const ::goby::moos::protobuf::TranslatorEntry& pAcommsHandlerConfig::_internal_translator_entry(int index) const {
  return _impl_.translator_entry_.Get(index);
}
inline const ::goby::moos::protobuf::TranslatorEntry& pAcommsHandlerConfig::translator_entry(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.translator_entry)
  return _internal_translator_entry(index);
}
inline ::goby::moos::protobuf::TranslatorEntry* pAcommsHandlerConfig::_internal_add_translator_entry() {
  return _impl_.translator_entry_.Add();
}
inline ::goby::moos::protobuf::TranslatorEntry* pAcommsHandlerConfig::add_translator_entry() {
  ::goby::moos::protobuf::TranslatorEntry* _add = _internal_add_translator_entry();
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.translator_entry)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::moos::protobuf::TranslatorEntry >&
pAcommsHandlerConfig::translator_entry() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.translator_entry)
  return _impl_.translator_entry_;
}
 
// repeated string multiplex_create_moos_var = 23 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_multiplex_create_moos_var_size() const {
  return _impl_.multiplex_create_moos_var_.size();
}
inline int pAcommsHandlerConfig::multiplex_create_moos_var_size() const {
  return _internal_multiplex_create_moos_var_size();
}
inline void pAcommsHandlerConfig::clear_multiplex_create_moos_var() {
  _impl_.multiplex_create_moos_var_.Clear();
}
inline std::string* pAcommsHandlerConfig::add_multiplex_create_moos_var() {
  std::string* _s = _internal_add_multiplex_create_moos_var();
  // @@protoc_insertion_point(field_add_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
  return _s;
}
inline const std::string& pAcommsHandlerConfig::_internal_multiplex_create_moos_var(int index) const {
  return _impl_.multiplex_create_moos_var_.Get(index);
}
inline const std::string& pAcommsHandlerConfig::multiplex_create_moos_var(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
  return _internal_multiplex_create_moos_var(index);
}
inline std::string* pAcommsHandlerConfig::mutable_multiplex_create_moos_var(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
  return _impl_.multiplex_create_moos_var_.Mutable(index);
}
inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const std::string& value) {
  _impl_.multiplex_create_moos_var_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, std::string&& value) {
  _impl_.multiplex_create_moos_var_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.multiplex_create_moos_var_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::set_multiplex_create_moos_var(int index, const char* value, size_t size) {
  _impl_.multiplex_create_moos_var_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline std::string* pAcommsHandlerConfig::_internal_add_multiplex_create_moos_var() {
  return _impl_.multiplex_create_moos_var_.Add();
}
inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const std::string& value) {
  _impl_.multiplex_create_moos_var_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(std::string&& value) {
  _impl_.multiplex_create_moos_var_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.multiplex_create_moos_var_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline void pAcommsHandlerConfig::add_multiplex_create_moos_var(const char* value, size_t size) {
  _impl_.multiplex_create_moos_var_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
pAcommsHandlerConfig::multiplex_create_moos_var() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
  return _impl_.multiplex_create_moos_var_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
pAcommsHandlerConfig::mutable_multiplex_create_moos_var() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.multiplex_create_moos_var)
  return &_impl_.multiplex_create_moos_var_;
}
 
// repeated string dccl_frontseat_forward_name = 24 [(.goby.field) = {
inline int pAcommsHandlerConfig::_internal_dccl_frontseat_forward_name_size() const {
  return _impl_.dccl_frontseat_forward_name_.size();
}
inline int pAcommsHandlerConfig::dccl_frontseat_forward_name_size() const {
  return _internal_dccl_frontseat_forward_name_size();
}
inline void pAcommsHandlerConfig::clear_dccl_frontseat_forward_name() {
  _impl_.dccl_frontseat_forward_name_.Clear();
}
inline std::string* pAcommsHandlerConfig::add_dccl_frontseat_forward_name() {
  std::string* _s = _internal_add_dccl_frontseat_forward_name();
  // @@protoc_insertion_point(field_add_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
  return _s;
}
inline const std::string& pAcommsHandlerConfig::_internal_dccl_frontseat_forward_name(int index) const {
  return _impl_.dccl_frontseat_forward_name_.Get(index);
}
inline const std::string& pAcommsHandlerConfig::dccl_frontseat_forward_name(int index) const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
  return _internal_dccl_frontseat_forward_name(index);
}
inline std::string* pAcommsHandlerConfig::mutable_dccl_frontseat_forward_name(int index) {
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
  return _impl_.dccl_frontseat_forward_name_.Mutable(index);
}
inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const std::string& value) {
  _impl_.dccl_frontseat_forward_name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, std::string&& value) {
  _impl_.dccl_frontseat_forward_name_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.dccl_frontseat_forward_name_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::set_dccl_frontseat_forward_name(int index, const char* value, size_t size) {
  _impl_.dccl_frontseat_forward_name_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline std::string* pAcommsHandlerConfig::_internal_add_dccl_frontseat_forward_name() {
  return _impl_.dccl_frontseat_forward_name_.Add();
}
inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const std::string& value) {
  _impl_.dccl_frontseat_forward_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(std::string&& value) {
  _impl_.dccl_frontseat_forward_name_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.dccl_frontseat_forward_name_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline void pAcommsHandlerConfig::add_dccl_frontseat_forward_name(const char* value, size_t size) {
  _impl_.dccl_frontseat_forward_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
pAcommsHandlerConfig::dccl_frontseat_forward_name() const {
  // @@protoc_insertion_point(field_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
  return _impl_.dccl_frontseat_forward_name_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
pAcommsHandlerConfig::mutable_dccl_frontseat_forward_name() {
  // @@protoc_insertion_point(field_mutable_list:goby.apps.moos.protobuf.pAcommsHandlerConfig.dccl_frontseat_forward_name)
  return &_impl_.dccl_frontseat_forward_name_;
}
 
// optional string modem_id_lookup_path = 101 [(.goby.field) = {
inline bool pAcommsHandlerConfig::_internal_has_modem_id_lookup_path() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool pAcommsHandlerConfig::has_modem_id_lookup_path() const {
  return _internal_has_modem_id_lookup_path();
}
inline void pAcommsHandlerConfig::clear_modem_id_lookup_path() {
  _impl_.modem_id_lookup_path_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& pAcommsHandlerConfig::modem_id_lookup_path() const {
  // @@protoc_insertion_point(field_get:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id_lookup_path)
  return _internal_modem_id_lookup_path();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void pAcommsHandlerConfig::set_modem_id_lookup_path(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.modem_id_lookup_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id_lookup_path)
}
inline std::string* pAcommsHandlerConfig::mutable_modem_id_lookup_path() {
  std::string* _s = _internal_mutable_modem_id_lookup_path();
  // @@protoc_insertion_point(field_mutable:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id_lookup_path)
  return _s;
}
inline const std::string& pAcommsHandlerConfig::_internal_modem_id_lookup_path() const {
  return _impl_.modem_id_lookup_path_.Get();
}
inline void pAcommsHandlerConfig::_internal_set_modem_id_lookup_path(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.modem_id_lookup_path_.Set(value, GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig::_internal_mutable_modem_id_lookup_path() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.modem_id_lookup_path_.Mutable(GetArenaForAllocation());
}
inline std::string* pAcommsHandlerConfig::release_modem_id_lookup_path() {
  // @@protoc_insertion_point(field_release:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id_lookup_path)
  if (!_internal_has_modem_id_lookup_path()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.modem_id_lookup_path_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.modem_id_lookup_path_.IsDefault()) {
    _impl_.modem_id_lookup_path_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void pAcommsHandlerConfig::set_allocated_modem_id_lookup_path(std::string* modem_id_lookup_path) {
  if (modem_id_lookup_path != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.modem_id_lookup_path_.SetAllocated(modem_id_lookup_path, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.modem_id_lookup_path_.IsDefault()) {
    _impl_.modem_id_lookup_path_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.apps.moos.protobuf.pAcommsHandlerConfig.modem_id_lookup_path)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace moos
}  // namespace apps
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique>() {
  return ::goby::apps::moos::protobuf::pAcommsHandlerConfig_DriverFailureApproach_DriverFailureTechnique_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_goby_2fmoos_2fprotobuf_2fpAcommsHandler_5fconfig_2eproto