iridium_driver.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/acomms/protobuf/iridium_driver.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2firidium_5fdriver_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/acomms/protobuf/driver_base.pb.h"
#include "goby/acomms/protobuf/modem_message.pb.h"
#include "dccl/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>
 
#include <boost/units/systems/angle/degrees.hpp>
 
#include <boost/units/systems/si.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
namespace goby {
namespace acomms {
namespace iridium {
namespace protobuf {
class Config;
struct ConfigDefaultTypeInternal;
extern ConfigDefaultTypeInternal _Config_default_instance_;
class Config_Remote;
struct Config_RemoteDefaultTypeInternal;
extern Config_RemoteDefaultTypeInternal _Config_Remote_default_instance_;
class IridiumHeader;
struct IridiumHeaderDefaultTypeInternal;
extern IridiumHeaderDefaultTypeInternal _IridiumHeader_default_instance_;
class Report;
struct ReportDefaultTypeInternal;
extern ReportDefaultTypeInternal _Report_default_instance_;
class RockblockReceive;
struct RockblockReceiveDefaultTypeInternal;
extern RockblockReceiveDefaultTypeInternal _RockblockReceive_default_instance_;
class RockblockTransmit;
struct RockblockTransmitDefaultTypeInternal;
extern RockblockTransmitDefaultTypeInternal _RockblockTransmit_default_instance_;
class Transmission;
struct TransmissionDefaultTypeInternal;
extern TransmissionDefaultTypeInternal _Transmission_default_instance_;
}  // namespace protobuf
}  // namespace iridium
}  // namespace acomms
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::acomms::iridium::protobuf::Config* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::Config>(Arena*);
template<> ::goby::acomms::iridium::protobuf::Config_Remote* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::Config_Remote>(Arena*);
template<> ::goby::acomms::iridium::protobuf::IridiumHeader* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::IridiumHeader>(Arena*);
template<> ::goby::acomms::iridium::protobuf::Report* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::Report>(Arena*);
template<> ::goby::acomms::iridium::protobuf::RockblockReceive* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::RockblockReceive>(Arena*);
template<> ::goby::acomms::iridium::protobuf::RockblockTransmit* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::RockblockTransmit>(Arena*);
template<> ::goby::acomms::iridium::protobuf::Transmission* Arena::CreateMaybeMessage<::goby::acomms::iridium::protobuf::Transmission>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace acomms {
namespace iridium {
namespace protobuf {
 
enum RockblockTransmit_Error : int {
  RockblockTransmit_Error_ERROR_SUCCESS = -1,
  RockblockTransmit_Error_ERROR_PARSE_FAILURE = -2,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_INVALID_LOGIN_CREDENTIALS = 10,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_IMEI_NOT_FOUND_ON_YOUR_ACCOUNT = 11,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_HAS_NO_LINE_RENTAL = 12,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_ACCOUNT_HAS_INSUFFICIENT_CREDIT = 13,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_COULD_NOT_DECODE_HEX_DATA = 14,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_DATA_TOO_LONG = 15,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_NO_DATA = 16,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_SYSTEM_ERROR = 99,
  RockblockTransmit_Error_ROCKBLOCK_ERROR_UNKNOWN = 100,
  RockblockTransmit_Error_HTTP_ERROR_UNKNOWN = 101,
  RockblockTransmit_Error_HTTP_ERROR_CONNECTION = 102,
  RockblockTransmit_Error_HTTP_ERROR_BINDIPADDRESS = 103,
  RockblockTransmit_Error_HTTP_ERROR_READ = 104,
  RockblockTransmit_Error_HTTP_ERROR_WRITE = 105,
  RockblockTransmit_Error_HTTP_ERROR_EXCEEDREDIRECTCOUNT = 106,
  RockblockTransmit_Error_HTTP_ERROR_CANCELED = 107,
  RockblockTransmit_Error_HTTP_ERROR_SSLCONNECTION = 108,
  RockblockTransmit_Error_HTTP_ERROR_SSLLOADINGCERTS = 109,
  RockblockTransmit_Error_HTTP_ERROR_SSLSERVERVERIFICATION = 110,
  RockblockTransmit_Error_HTTP_ERROR_UNSUPPORTEDMULTIPARTBOUNDARYCHARS = 111,
  RockblockTransmit_Error_HTTP_ERROR_COMPRESSION = 112,
  RockblockTransmit_Error_HTTP_ERROR_CONNECTIONTIMEOUT = 113,
  RockblockTransmit_Error_HTTP_ERROR_PROXYCONNECTION = 114
};
bool RockblockTransmit_Error_IsValid(int value);
constexpr RockblockTransmit_Error RockblockTransmit_Error_Error_MIN = RockblockTransmit_Error_ERROR_PARSE_FAILURE;
constexpr RockblockTransmit_Error RockblockTransmit_Error_Error_MAX = RockblockTransmit_Error_HTTP_ERROR_PROXYCONNECTION;
constexpr int RockblockTransmit_Error_Error_ARRAYSIZE = RockblockTransmit_Error_Error_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RockblockTransmit_Error_descriptor();
template<typename T>
inline const std::string& RockblockTransmit_Error_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RockblockTransmit_Error>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RockblockTransmit_Error_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RockblockTransmit_Error_descriptor(), enum_t_value);
}
inline bool RockblockTransmit_Error_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RockblockTransmit_Error* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RockblockTransmit_Error>(
    RockblockTransmit_Error_descriptor(), name, value);
}
enum Report_RSSI : int {
  Report_RSSI_RSSI_0_BARS = 0,
  Report_RSSI_RSSI_1_BARS = 1,
  Report_RSSI_RSSI_2_BARS = 2,
  Report_RSSI_RSSI_3_BARS = 3,
  Report_RSSI_RSSI_4_BARS = 4,
  Report_RSSI_RSSI_5_BARS = 5
};
bool Report_RSSI_IsValid(int value);
constexpr Report_RSSI Report_RSSI_RSSI_MIN = Report_RSSI_RSSI_0_BARS;
constexpr Report_RSSI Report_RSSI_RSSI_MAX = Report_RSSI_RSSI_5_BARS;
constexpr int Report_RSSI_RSSI_ARRAYSIZE = Report_RSSI_RSSI_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Report_RSSI_descriptor();
template<typename T>
inline const std::string& Report_RSSI_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Report_RSSI>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Report_RSSI_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Report_RSSI_descriptor(), enum_t_value);
}
inline bool Report_RSSI_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Report_RSSI* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Report_RSSI>(
    Report_RSSI_descriptor(), name, value);
}
enum DeviceType : int {
  DEVICE_VOICE_ENABLED_ISU = 1,
  DEVICE_IRIDIUM_9602_9603 = 2
};
bool DeviceType_IsValid(int value);
constexpr DeviceType DeviceType_MIN = DEVICE_VOICE_ENABLED_ISU;
constexpr DeviceType DeviceType_MAX = DEVICE_IRIDIUM_9602_9603;
constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceType_descriptor();
template<typename T>
inline const std::string& DeviceType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceType_descriptor(), enum_t_value);
}
inline bool DeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceType>(
    DeviceType_descriptor(), name, value);
}
// ===================================================================
 
class Config_Remote final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.Config.Remote) */ {
 public:
  inline Config_Remote() : Config_Remote(nullptr) {}
  ~Config_Remote() override;
  explicit PROTOBUF_CONSTEXPR Config_Remote(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Config_Remote(const Config_Remote& from);
  Config_Remote(Config_Remote&& from) noexcept
    : Config_Remote() {
    *this = ::std::move(from);
  }
 
  inline Config_Remote& operator=(const Config_Remote& from) {
    CopyFrom(from);
    return *this;
  }
  inline Config_Remote& operator=(Config_Remote&& 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 Config_Remote& default_instance() {
    return *internal_default_instance();
  }
  static inline const Config_Remote* internal_default_instance() {
    return reinterpret_cast<const Config_Remote*>(
               &_Config_Remote_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(Config_Remote& a, Config_Remote& b) {
    a.Swap(&b);
  }
  inline void Swap(Config_Remote* 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(Config_Remote* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Config_Remote* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Config_Remote>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Config_Remote& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Config_Remote& from) {
    Config_Remote::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(Config_Remote* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.Config.Remote";
  }
  protected:
  explicit Config_Remote(::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 {
    kIridiumNumberFieldNumber = 1,
    kModemIdFieldNumber = 2,
  };
  // required string iridium_number = 1;
  bool has_iridium_number() const;
  private:
  bool _internal_has_iridium_number() const;
  public:
  void clear_iridium_number();
  const std::string& iridium_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_iridium_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_iridium_number();
  PROTOBUF_NODISCARD std::string* release_iridium_number();
  void set_allocated_iridium_number(std::string* iridium_number);
  private:
  const std::string& _internal_iridium_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iridium_number(const std::string& value);
  std::string* _internal_mutable_iridium_number();
  public:
 
  // required int32 modem_id = 2;
  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.acomms.iridium.protobuf.Config.Remote)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iridium_number_;
    int32_t modem_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Config final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.Config) */ {
 public:
  inline Config() : Config(nullptr) {}
  ~Config() override;
  explicit PROTOBUF_CONSTEXPR Config(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Config(const Config& from);
  Config(Config&& from) noexcept
    : Config() {
    *this = ::std::move(from);
  }
 
  inline Config& operator=(const Config& from) {
    CopyFrom(from);
    return *this;
  }
  inline Config& operator=(Config&& 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 Config& default_instance() {
    return *internal_default_instance();
  }
  static inline const Config* internal_default_instance() {
    return reinterpret_cast<const Config*>(
               &_Config_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(Config& a, Config& b) {
    a.Swap(&b);
  }
  inline void Swap(Config* 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(Config* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Config* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Config>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Config& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Config& from) {
    Config::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(Config* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.Config";
  }
  protected:
  explicit Config(::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 Config_Remote Remote;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kConfigFieldNumber = 4,
    kRemoteFieldNumber = 1,
    kDebugClientPortFieldNumber = 6,
    kUseDtrFieldNumber = 10,
    kMaxFrameSizeFieldNumber = 2,
    kTargetBitRateFieldNumber = 3,
    kDialAttemptsFieldNumber = 5,
    kHangupSecondsAfterEmptyFieldNumber = 8,
    kStartTimeoutFieldNumber = 9,
    kHandshakeHangupSecondsFieldNumber = 12,
    kEnableSbdringAutomaticRegistrationFieldNumber = 13,
    kDeviceFieldNumber = 14,
  };
  // repeated string config = 4;
  int config_size() const;
  private:
  int _internal_config_size() const;
  public:
  void clear_config();
  const std::string& config(int index) const;
  std::string* mutable_config(int index);
  void set_config(int index, const std::string& value);
  void set_config(int index, std::string&& value);
  void set_config(int index, const char* value);
  void set_config(int index, const char* value, size_t size);
  std::string* add_config();
  void add_config(const std::string& value);
  void add_config(std::string&& value);
  void add_config(const char* value);
  void add_config(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& config() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_config();
  private:
  const std::string& _internal_config(int index) const;
  std::string* _internal_add_config();
  public:
 
  // optional .goby.acomms.iridium.protobuf.Config.Remote remote = 1;
  bool has_remote() const;
  private:
  bool _internal_has_remote() const;
  public:
  void clear_remote();
  const ::goby::acomms::iridium::protobuf::Config_Remote& remote() const;
  PROTOBUF_NODISCARD ::goby::acomms::iridium::protobuf::Config_Remote* release_remote();
  ::goby::acomms::iridium::protobuf::Config_Remote* mutable_remote();
  void set_allocated_remote(::goby::acomms::iridium::protobuf::Config_Remote* remote);
  private:
  const ::goby::acomms::iridium::protobuf::Config_Remote& _internal_remote() const;
  ::goby::acomms::iridium::protobuf::Config_Remote* _internal_mutable_remote();
  public:
  void unsafe_arena_set_allocated_remote(
      ::goby::acomms::iridium::protobuf::Config_Remote* remote);
  ::goby::acomms::iridium::protobuf::Config_Remote* unsafe_arena_release_remote();
 
  // optional int32 debug_client_port = 6;
  bool has_debug_client_port() const;
  private:
  bool _internal_has_debug_client_port() const;
  public:
  void clear_debug_client_port();
  int32_t debug_client_port() const;
  void set_debug_client_port(int32_t value);
  private:
  int32_t _internal_debug_client_port() const;
  void _internal_set_debug_client_port(int32_t value);
  public:
 
  // optional bool use_dtr = 10 [default = false];
  bool has_use_dtr() const;
  private:
  bool _internal_has_use_dtr() const;
  public:
  void clear_use_dtr();
  bool use_dtr() const;
  void set_use_dtr(bool value);
  private:
  bool _internal_use_dtr() const;
  void _internal_set_use_dtr(bool value);
  public:
 
  // optional uint32 max_frame_size = 2 [default = 1500];
  bool has_max_frame_size() const;
  private:
  bool _internal_has_max_frame_size() const;
  public:
  void clear_max_frame_size();
  uint32_t max_frame_size() const;
  void set_max_frame_size(uint32_t value);
  private:
  uint32_t _internal_max_frame_size() const;
  void _internal_set_max_frame_size(uint32_t value);
  public:
 
  // optional int32 target_bit_rate = 3 [default = 2400];
  bool has_target_bit_rate() const;
  private:
  bool _internal_has_target_bit_rate() const;
  public:
  void clear_target_bit_rate();
  int32_t target_bit_rate() const;
  void set_target_bit_rate(int32_t value);
  private:
  int32_t _internal_target_bit_rate() const;
  void _internal_set_target_bit_rate(int32_t value);
  public:
 
  // optional int32 dial_attempts = 5 [default = 3];
  bool has_dial_attempts() const;
  private:
  bool _internal_has_dial_attempts() const;
  public:
  void clear_dial_attempts();
  int32_t dial_attempts() const;
  void set_dial_attempts(int32_t value);
  private:
  int32_t _internal_dial_attempts() const;
  void _internal_set_dial_attempts(int32_t value);
  public:
 
  // optional int32 hangup_seconds_after_empty = 8 [default = 30];
  bool has_hangup_seconds_after_empty() const;
  private:
  bool _internal_has_hangup_seconds_after_empty() const;
  public:
  void clear_hangup_seconds_after_empty();
  int32_t hangup_seconds_after_empty() const;
  void set_hangup_seconds_after_empty(int32_t value);
  private:
  int32_t _internal_hangup_seconds_after_empty() const;
  void _internal_set_hangup_seconds_after_empty(int32_t value);
  public:
 
  // optional int32 start_timeout = 9 [default = 20];
  bool has_start_timeout() const;
  private:
  bool _internal_has_start_timeout() const;
  public:
  void clear_start_timeout();
  int32_t start_timeout() const;
  void set_start_timeout(int32_t value);
  private:
  int32_t _internal_start_timeout() const;
  void _internal_set_start_timeout(int32_t value);
  public:
 
  // optional int32 handshake_hangup_seconds = 12 [default = 5];
  bool has_handshake_hangup_seconds() const;
  private:
  bool _internal_has_handshake_hangup_seconds() const;
  public:
  void clear_handshake_hangup_seconds();
  int32_t handshake_hangup_seconds() const;
  void set_handshake_hangup_seconds(int32_t value);
  private:
  int32_t _internal_handshake_hangup_seconds() const;
  void _internal_set_handshake_hangup_seconds(int32_t value);
  public:
 
  // optional bool enable_sbdring_automatic_registration = 13 [default = true];
  bool has_enable_sbdring_automatic_registration() const;
  private:
  bool _internal_has_enable_sbdring_automatic_registration() const;
  public:
  void clear_enable_sbdring_automatic_registration();
  bool enable_sbdring_automatic_registration() const;
  void set_enable_sbdring_automatic_registration(bool value);
  private:
  bool _internal_enable_sbdring_automatic_registration() const;
  void _internal_set_enable_sbdring_automatic_registration(bool value);
  public:
 
  // optional .goby.acomms.iridium.protobuf.DeviceType device = 14 [default = DEVICE_VOICE_ENABLED_ISU];
  bool has_device() const;
  private:
  bool _internal_has_device() const;
  public:
  void clear_device();
  ::goby::acomms::iridium::protobuf::DeviceType device() const;
  void set_device(::goby::acomms::iridium::protobuf::DeviceType value);
  private:
  ::goby::acomms::iridium::protobuf::DeviceType _internal_device() const;
  void _internal_set_device(::goby::acomms::iridium::protobuf::DeviceType value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.Config)
 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> config_;
    ::goby::acomms::iridium::protobuf::Config_Remote* remote_;
    int32_t debug_client_port_;
    bool use_dtr_;
    uint32_t max_frame_size_;
    int32_t target_bit_rate_;
    int32_t dial_attempts_;
    int32_t hangup_seconds_after_empty_;
    int32_t start_timeout_;
    int32_t handshake_hangup_seconds_;
    bool enable_sbdring_automatic_registration_;
    int device_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class RockblockReceive final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.RockblockReceive) */ {
 public:
  inline RockblockReceive() : RockblockReceive(nullptr) {}
  ~RockblockReceive() override;
  explicit PROTOBUF_CONSTEXPR RockblockReceive(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  RockblockReceive(const RockblockReceive& from);
  RockblockReceive(RockblockReceive&& from) noexcept
    : RockblockReceive() {
    *this = ::std::move(from);
  }
 
  inline RockblockReceive& operator=(const RockblockReceive& from) {
    CopyFrom(from);
    return *this;
  }
  inline RockblockReceive& operator=(RockblockReceive&& 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 RockblockReceive& default_instance() {
    return *internal_default_instance();
  }
  static inline const RockblockReceive* internal_default_instance() {
    return reinterpret_cast<const RockblockReceive*>(
               &_RockblockReceive_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(RockblockReceive& a, RockblockReceive& b) {
    a.Swap(&b);
  }
  inline void Swap(RockblockReceive* 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(RockblockReceive* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  RockblockReceive* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RockblockReceive>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RockblockReceive& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RockblockReceive& from) {
    RockblockReceive::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(RockblockReceive* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.RockblockReceive";
  }
  protected:
  explicit RockblockReceive(::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 {
    kImeiFieldNumber = 6,
    kDeviceTypeFieldNumber = 7,
    kTransmitTimeFieldNumber = 8,
    kIridiumLatitudeFieldNumber = 2,
    kIridiumLongitudeFieldNumber = 3,
    kMomsnFieldNumber = 1,
    kSerialFieldNumber = 5,
    kIridiumCepRadiusFieldNumber = 4,
    kJwtVerifiedFieldNumber = 9,
  };
  // optional string imei = 6;
  bool has_imei() const;
  private:
  bool _internal_has_imei() const;
  public:
  void clear_imei();
  const std::string& imei() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_imei(ArgT0&& arg0, ArgT... args);
  std::string* mutable_imei();
  PROTOBUF_NODISCARD std::string* release_imei();
  void set_allocated_imei(std::string* imei);
  private:
  const std::string& _internal_imei() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_imei(const std::string& value);
  std::string* _internal_mutable_imei();
  public:
 
  // optional string device_type = 7;
  bool has_device_type() const;
  private:
  bool _internal_has_device_type() const;
  public:
  void clear_device_type();
  const std::string& device_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_type();
  PROTOBUF_NODISCARD std::string* release_device_type();
  void set_allocated_device_type(std::string* device_type);
  private:
  const std::string& _internal_device_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
  std::string* _internal_mutable_device_type();
  public:
 
  // optional string transmit_time = 8;
  bool has_transmit_time() const;
  private:
  bool _internal_has_transmit_time() const;
  public:
  void clear_transmit_time();
  const std::string& transmit_time() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_transmit_time(ArgT0&& arg0, ArgT... args);
  std::string* mutable_transmit_time();
  PROTOBUF_NODISCARD std::string* release_transmit_time();
  void set_allocated_transmit_time(std::string* transmit_time);
  private:
  const std::string& _internal_transmit_time() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_transmit_time(const std::string& value);
  std::string* _internal_mutable_transmit_time();
  public:
 
  // optional double iridium_latitude = 2 [(.dccl.field) = {
  bool has_iridium_latitude() const;
  private:
  bool _internal_has_iridium_latitude() const;
  public:
  void clear_iridium_latitude();
  double iridium_latitude() const;
  void set_iridium_latitude(double value);
  private:
  double _internal_iridium_latitude() const;
  void _internal_set_iridium_latitude(double value);
  public:
 
  // optional double iridium_longitude = 3 [(.dccl.field) = {
  bool has_iridium_longitude() const;
  private:
  bool _internal_has_iridium_longitude() const;
  public:
  void clear_iridium_longitude();
  double iridium_longitude() const;
  void set_iridium_longitude(double value);
  private:
  double _internal_iridium_longitude() const;
  void _internal_set_iridium_longitude(double value);
  public:
 
  // optional int32 momsn = 1;
  bool has_momsn() const;
  private:
  bool _internal_has_momsn() const;
  public:
  void clear_momsn();
  int32_t momsn() const;
  void set_momsn(int32_t value);
  private:
  int32_t _internal_momsn() const;
  void _internal_set_momsn(int32_t value);
  public:
 
  // optional int32 serial = 5;
  bool has_serial() const;
  private:
  bool _internal_has_serial() const;
  public:
  void clear_serial();
  int32_t serial() const;
  void set_serial(int32_t value);
  private:
  int32_t _internal_serial() const;
  void _internal_set_serial(int32_t value);
  public:
 
  // optional double iridium_cep_radius = 4 [(.dccl.field) = {
  bool has_iridium_cep_radius() const;
  private:
  bool _internal_has_iridium_cep_radius() const;
  public:
  void clear_iridium_cep_radius();
  double iridium_cep_radius() const;
  void set_iridium_cep_radius(double value);
  private:
  double _internal_iridium_cep_radius() const;
  void _internal_set_iridium_cep_radius(double value);
  public:
 
  // optional bool jwt_verified = 9 [default = false];
  bool has_jwt_verified() const;
  private:
  bool _internal_has_jwt_verified() const;
  public:
  void clear_jwt_verified();
  bool jwt_verified() const;
  void set_jwt_verified(bool value);
  private:
  bool _internal_jwt_verified() const;
  void _internal_set_jwt_verified(bool value);
  public:
 
  typedef boost::units::plane_angle_dimension iridium_latitude_dimension;
  
  typedef boost::units::unit<iridium_latitude_dimension,boost::units::degree::system> iridium_latitude_unit;
  
  template<typename Quantity >
    void set_iridium_latitude_with_units(Quantity value_w_units)
    { set_iridium_latitude(boost::units::quantity<iridium_latitude_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity iridium_latitude_with_units() const
    { return Quantity(iridium_latitude() * iridium_latitude_unit()); };
  
  boost::units::quantity< iridium_latitude_unit,double > iridium_latitude_with_units() const
    { return iridium_latitude_with_units<boost::units::quantity< iridium_latitude_unit,double > >(); };
  
  typedef boost::units::plane_angle_dimension iridium_longitude_dimension;
  
  typedef boost::units::unit<iridium_longitude_dimension,boost::units::degree::system> iridium_longitude_unit;
  
  template<typename Quantity >
    void set_iridium_longitude_with_units(Quantity value_w_units)
    { set_iridium_longitude(boost::units::quantity<iridium_longitude_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity iridium_longitude_with_units() const
    { return Quantity(iridium_longitude() * iridium_longitude_unit()); };
  
  boost::units::quantity< iridium_longitude_unit,double > iridium_longitude_with_units() const
    { return iridium_longitude_with_units<boost::units::quantity< iridium_longitude_unit,double > >(); };
  
  typedef boost::units::length_dimension iridium_cep_radius_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<iridium_cep_radius_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<3> > >::type iridium_cep_radius_unit;
  
  template<typename Quantity >
    void set_iridium_cep_radius_with_units(Quantity value_w_units)
    { set_iridium_cep_radius(boost::units::quantity<iridium_cep_radius_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity iridium_cep_radius_with_units() const
    { return Quantity(iridium_cep_radius() * iridium_cep_radius_unit()); };
  
  boost::units::quantity< iridium_cep_radius_unit,double > iridium_cep_radius_with_units() const
    { return iridium_cep_radius_with_units<boost::units::quantity< iridium_cep_radius_unit,double > >(); };
  
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.RockblockReceive)
 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::internal::ArenaStringPtr imei_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr transmit_time_;
    double iridium_latitude_;
    double iridium_longitude_;
    int32_t momsn_;
    int32_t serial_;
    double iridium_cep_radius_;
    bool jwt_verified_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class RockblockTransmit final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.RockblockTransmit) */ {
 public:
  inline RockblockTransmit() : RockblockTransmit(nullptr) {}
  ~RockblockTransmit() override;
  explicit PROTOBUF_CONSTEXPR RockblockTransmit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  RockblockTransmit(const RockblockTransmit& from);
  RockblockTransmit(RockblockTransmit&& from) noexcept
    : RockblockTransmit() {
    *this = ::std::move(from);
  }
 
  inline RockblockTransmit& operator=(const RockblockTransmit& from) {
    CopyFrom(from);
    return *this;
  }
  inline RockblockTransmit& operator=(RockblockTransmit&& 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 RockblockTransmit& default_instance() {
    return *internal_default_instance();
  }
  static inline const RockblockTransmit* internal_default_instance() {
    return reinterpret_cast<const RockblockTransmit*>(
               &_RockblockTransmit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(RockblockTransmit& a, RockblockTransmit& b) {
    a.Swap(&b);
  }
  inline void Swap(RockblockTransmit* 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(RockblockTransmit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  RockblockTransmit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RockblockTransmit>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RockblockTransmit& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RockblockTransmit& from) {
    RockblockTransmit::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(RockblockTransmit* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.RockblockTransmit";
  }
  protected:
  explicit RockblockTransmit(::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 RockblockTransmit_Error Error;
  static constexpr Error ERROR_SUCCESS =
    RockblockTransmit_Error_ERROR_SUCCESS;
  static constexpr Error ERROR_PARSE_FAILURE =
    RockblockTransmit_Error_ERROR_PARSE_FAILURE;
  static constexpr Error ROCKBLOCK_ERROR_INVALID_LOGIN_CREDENTIALS =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_INVALID_LOGIN_CREDENTIALS;
  static constexpr Error ROCKBLOCK_ERROR_IMEI_NOT_FOUND_ON_YOUR_ACCOUNT =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_IMEI_NOT_FOUND_ON_YOUR_ACCOUNT;
  static constexpr Error ROCKBLOCK_ERROR_HAS_NO_LINE_RENTAL =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_HAS_NO_LINE_RENTAL;
  static constexpr Error ROCKBLOCK_ERROR_ACCOUNT_HAS_INSUFFICIENT_CREDIT =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_ACCOUNT_HAS_INSUFFICIENT_CREDIT;
  static constexpr Error ROCKBLOCK_ERROR_COULD_NOT_DECODE_HEX_DATA =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_COULD_NOT_DECODE_HEX_DATA;
  static constexpr Error ROCKBLOCK_ERROR_DATA_TOO_LONG =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_DATA_TOO_LONG;
  static constexpr Error ROCKBLOCK_ERROR_NO_DATA =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_NO_DATA;
  static constexpr Error ROCKBLOCK_ERROR_SYSTEM_ERROR =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_SYSTEM_ERROR;
  static constexpr Error ROCKBLOCK_ERROR_UNKNOWN =
    RockblockTransmit_Error_ROCKBLOCK_ERROR_UNKNOWN;
  static constexpr Error HTTP_ERROR_UNKNOWN =
    RockblockTransmit_Error_HTTP_ERROR_UNKNOWN;
  static constexpr Error HTTP_ERROR_CONNECTION =
    RockblockTransmit_Error_HTTP_ERROR_CONNECTION;
  static constexpr Error HTTP_ERROR_BINDIPADDRESS =
    RockblockTransmit_Error_HTTP_ERROR_BINDIPADDRESS;
  static constexpr Error HTTP_ERROR_READ =
    RockblockTransmit_Error_HTTP_ERROR_READ;
  static constexpr Error HTTP_ERROR_WRITE =
    RockblockTransmit_Error_HTTP_ERROR_WRITE;
  static constexpr Error HTTP_ERROR_EXCEEDREDIRECTCOUNT =
    RockblockTransmit_Error_HTTP_ERROR_EXCEEDREDIRECTCOUNT;
  static constexpr Error HTTP_ERROR_CANCELED =
    RockblockTransmit_Error_HTTP_ERROR_CANCELED;
  static constexpr Error HTTP_ERROR_SSLCONNECTION =
    RockblockTransmit_Error_HTTP_ERROR_SSLCONNECTION;
  static constexpr Error HTTP_ERROR_SSLLOADINGCERTS =
    RockblockTransmit_Error_HTTP_ERROR_SSLLOADINGCERTS;
  static constexpr Error HTTP_ERROR_SSLSERVERVERIFICATION =
    RockblockTransmit_Error_HTTP_ERROR_SSLSERVERVERIFICATION;
  static constexpr Error HTTP_ERROR_UNSUPPORTEDMULTIPARTBOUNDARYCHARS =
    RockblockTransmit_Error_HTTP_ERROR_UNSUPPORTEDMULTIPARTBOUNDARYCHARS;
  static constexpr Error HTTP_ERROR_COMPRESSION =
    RockblockTransmit_Error_HTTP_ERROR_COMPRESSION;
  static constexpr Error HTTP_ERROR_CONNECTIONTIMEOUT =
    RockblockTransmit_Error_HTTP_ERROR_CONNECTIONTIMEOUT;
  static constexpr Error HTTP_ERROR_PROXYCONNECTION =
    RockblockTransmit_Error_HTTP_ERROR_PROXYCONNECTION;
  static inline bool Error_IsValid(int value) {
    return RockblockTransmit_Error_IsValid(value);
  }
  static constexpr Error Error_MIN =
    RockblockTransmit_Error_Error_MIN;
  static constexpr Error Error_MAX =
    RockblockTransmit_Error_Error_MAX;
  static constexpr int Error_ARRAYSIZE =
    RockblockTransmit_Error_Error_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Error_descriptor() {
    return RockblockTransmit_Error_descriptor();
  }
  template<typename T>
  static inline const std::string& Error_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Error>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Error_Name.");
    return RockblockTransmit_Error_Name(enum_t_value);
  }
  static inline bool Error_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Error* value) {
    return RockblockTransmit_Error_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSuccessFieldNumber = 1,
    kMtIdFieldNumber = 2,
    kErrorFieldNumber = 10,
  };
  // required bool success = 1;
  bool has_success() const;
  private:
  bool _internal_has_success() const;
  public:
  void clear_success();
  bool success() const;
  void set_success(bool value);
  private:
  bool _internal_success() const;
  void _internal_set_success(bool value);
  public:
 
  // optional int32 mt_id = 2;
  bool has_mt_id() const;
  private:
  bool _internal_has_mt_id() const;
  public:
  void clear_mt_id();
  int32_t mt_id() const;
  void set_mt_id(int32_t value);
  private:
  int32_t _internal_mt_id() const;
  void _internal_set_mt_id(int32_t value);
  public:
 
  // optional .goby.acomms.iridium.protobuf.RockblockTransmit.Error error = 10 [default = ERROR_SUCCESS];
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  ::goby::acomms::iridium::protobuf::RockblockTransmit_Error error() const;
  void set_error(::goby::acomms::iridium::protobuf::RockblockTransmit_Error value);
  private:
  ::goby::acomms::iridium::protobuf::RockblockTransmit_Error _internal_error() const;
  void _internal_set_error(::goby::acomms::iridium::protobuf::RockblockTransmit_Error value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.RockblockTransmit)
 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_;
    bool success_;
    int32_t mt_id_;
    int error_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Transmission final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.Transmission) */ {
 public:
  inline Transmission() : Transmission(nullptr) {}
  ~Transmission() override;
  explicit PROTOBUF_CONSTEXPR Transmission(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Transmission(const Transmission& from);
  Transmission(Transmission&& from) noexcept
    : Transmission() {
    *this = ::std::move(from);
  }
 
  inline Transmission& operator=(const Transmission& from) {
    CopyFrom(from);
    return *this;
  }
  inline Transmission& operator=(Transmission&& 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 Transmission& default_instance() {
    return *internal_default_instance();
  }
  static inline const Transmission* internal_default_instance() {
    return reinterpret_cast<const Transmission*>(
               &_Transmission_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(Transmission& a, Transmission& b) {
    a.Swap(&b);
  }
  inline void Swap(Transmission* 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(Transmission* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Transmission* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Transmission>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Transmission& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Transmission& from) {
    Transmission::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(Transmission* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.Transmission";
  }
  protected:
  explicit Transmission(::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 {
    kRockblockRxFieldNumber = 10,
    kRockblockTxFieldNumber = 11,
    kIfNoDataDoMailboxCheckFieldNumber = 1,
  };
  // optional .goby.acomms.iridium.protobuf.RockblockReceive rockblock_rx = 10;
  bool has_rockblock_rx() const;
  private:
  bool _internal_has_rockblock_rx() const;
  public:
  void clear_rockblock_rx();
  const ::goby::acomms::iridium::protobuf::RockblockReceive& rockblock_rx() const;
  PROTOBUF_NODISCARD ::goby::acomms::iridium::protobuf::RockblockReceive* release_rockblock_rx();
  ::goby::acomms::iridium::protobuf::RockblockReceive* mutable_rockblock_rx();
  void set_allocated_rockblock_rx(::goby::acomms::iridium::protobuf::RockblockReceive* rockblock_rx);
  private:
  const ::goby::acomms::iridium::protobuf::RockblockReceive& _internal_rockblock_rx() const;
  ::goby::acomms::iridium::protobuf::RockblockReceive* _internal_mutable_rockblock_rx();
  public:
  void unsafe_arena_set_allocated_rockblock_rx(
      ::goby::acomms::iridium::protobuf::RockblockReceive* rockblock_rx);
  ::goby::acomms::iridium::protobuf::RockblockReceive* unsafe_arena_release_rockblock_rx();
 
  // optional .goby.acomms.iridium.protobuf.RockblockTransmit rockblock_tx = 11;
  bool has_rockblock_tx() const;
  private:
  bool _internal_has_rockblock_tx() const;
  public:
  void clear_rockblock_tx();
  const ::goby::acomms::iridium::protobuf::RockblockTransmit& rockblock_tx() const;
  PROTOBUF_NODISCARD ::goby::acomms::iridium::protobuf::RockblockTransmit* release_rockblock_tx();
  ::goby::acomms::iridium::protobuf::RockblockTransmit* mutable_rockblock_tx();
  void set_allocated_rockblock_tx(::goby::acomms::iridium::protobuf::RockblockTransmit* rockblock_tx);
  private:
  const ::goby::acomms::iridium::protobuf::RockblockTransmit& _internal_rockblock_tx() const;
  ::goby::acomms::iridium::protobuf::RockblockTransmit* _internal_mutable_rockblock_tx();
  public:
  void unsafe_arena_set_allocated_rockblock_tx(
      ::goby::acomms::iridium::protobuf::RockblockTransmit* rockblock_tx);
  ::goby::acomms::iridium::protobuf::RockblockTransmit* unsafe_arena_release_rockblock_tx();
 
  // optional bool if_no_data_do_mailbox_check = 1 [default = true];
  bool has_if_no_data_do_mailbox_check() const;
  private:
  bool _internal_has_if_no_data_do_mailbox_check() const;
  public:
  void clear_if_no_data_do_mailbox_check();
  bool if_no_data_do_mailbox_check() const;
  void set_if_no_data_do_mailbox_check(bool value);
  private:
  bool _internal_if_no_data_do_mailbox_check() const;
  void _internal_set_if_no_data_do_mailbox_check(bool value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.Transmission)
 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_;
    ::goby::acomms::iridium::protobuf::RockblockReceive* rockblock_rx_;
    ::goby::acomms::iridium::protobuf::RockblockTransmit* rockblock_tx_;
    bool if_no_data_do_mailbox_check_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class Report final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.Report) */ {
 public:
  inline Report() : Report(nullptr) {}
  ~Report() override;
  explicit PROTOBUF_CONSTEXPR Report(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Report(const Report& from);
  Report(Report&& from) noexcept
    : Report() {
    *this = ::std::move(from);
  }
 
  inline Report& operator=(const Report& from) {
    CopyFrom(from);
    return *this;
  }
  inline Report& operator=(Report&& 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 Report& default_instance() {
    return *internal_default_instance();
  }
  static inline const Report* internal_default_instance() {
    return reinterpret_cast<const Report*>(
               &_Report_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(Report& a, Report& b) {
    a.Swap(&b);
  }
  inline void Swap(Report* 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(Report* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Report* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Report>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Report& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Report& from) {
    Report::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(Report* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.Report";
  }
  protected:
  explicit Report(::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 Report_RSSI RSSI;
  static constexpr RSSI RSSI_0_BARS =
    Report_RSSI_RSSI_0_BARS;
  static constexpr RSSI RSSI_1_BARS =
    Report_RSSI_RSSI_1_BARS;
  static constexpr RSSI RSSI_2_BARS =
    Report_RSSI_RSSI_2_BARS;
  static constexpr RSSI RSSI_3_BARS =
    Report_RSSI_RSSI_3_BARS;
  static constexpr RSSI RSSI_4_BARS =
    Report_RSSI_RSSI_4_BARS;
  static constexpr RSSI RSSI_5_BARS =
    Report_RSSI_RSSI_5_BARS;
  static inline bool RSSI_IsValid(int value) {
    return Report_RSSI_IsValid(value);
  }
  static constexpr RSSI RSSI_MIN =
    Report_RSSI_RSSI_MIN;
  static constexpr RSSI RSSI_MAX =
    Report_RSSI_RSSI_MAX;
  static constexpr int RSSI_ARRAYSIZE =
    Report_RSSI_RSSI_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RSSI_descriptor() {
    return Report_RSSI_descriptor();
  }
  template<typename T>
  static inline const std::string& RSSI_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RSSI>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RSSI_Name.");
    return Report_RSSI_Name(enum_t_value);
  }
  static inline bool RSSI_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RSSI* value) {
    return Report_RSSI_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRssiFieldNumber = 1,
  };
  // optional .goby.acomms.iridium.protobuf.Report.RSSI rssi = 1;
  bool has_rssi() const;
  private:
  bool _internal_has_rssi() const;
  public:
  void clear_rssi();
  ::goby::acomms::iridium::protobuf::Report_RSSI rssi() const;
  void set_rssi(::goby::acomms::iridium::protobuf::Report_RSSI value);
  private:
  ::goby::acomms::iridium::protobuf::Report_RSSI _internal_rssi() const;
  void _internal_set_rssi(::goby::acomms::iridium::protobuf::Report_RSSI value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.Report)
 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_;
    int rssi_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// -------------------------------------------------------------------
 
class IridiumHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.iridium.protobuf.IridiumHeader) */ {
 public:
  inline IridiumHeader() : IridiumHeader(nullptr) {}
  ~IridiumHeader() override;
  explicit PROTOBUF_CONSTEXPR IridiumHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IridiumHeader(const IridiumHeader& from);
  IridiumHeader(IridiumHeader&& from) noexcept
    : IridiumHeader() {
    *this = ::std::move(from);
  }
 
  inline IridiumHeader& operator=(const IridiumHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline IridiumHeader& operator=(IridiumHeader&& 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 IridiumHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const IridiumHeader* internal_default_instance() {
    return reinterpret_cast<const IridiumHeader*>(
               &_IridiumHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(IridiumHeader& a, IridiumHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(IridiumHeader* 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(IridiumHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IridiumHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IridiumHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IridiumHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IridiumHeader& from) {
    IridiumHeader::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(IridiumHeader* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.iridium.protobuf.IridiumHeader";
  }
  protected:
  explicit IridiumHeader(::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 {
    kSrcFieldNumber = 1,
    kDestFieldNumber = 2,
    kRateFieldNumber = 3,
    kAckRequestedFieldNumber = 5,
    kFrameStartFieldNumber = 6,
    kAckedFrameFieldNumber = 7,
    kTypeFieldNumber = 4,
  };
  // required int32 src = 1 [(.dccl.field) = {
  bool has_src() const;
  private:
  bool _internal_has_src() const;
  public:
  void clear_src();
  int32_t src() const;
  void set_src(int32_t value);
  private:
  int32_t _internal_src() const;
  void _internal_set_src(int32_t value);
  public:
 
  // required int32 dest = 2 [(.dccl.field) = {
  bool has_dest() const;
  private:
  bool _internal_has_dest() const;
  public:
  void clear_dest();
  int32_t dest() const;
  void set_dest(int32_t value);
  private:
  int32_t _internal_dest() const;
  void _internal_set_dest(int32_t value);
  public:
 
  // optional int32 rate = 3 [(.dccl.field) = {
  bool has_rate() const;
  private:
  bool _internal_has_rate() const;
  public:
  void clear_rate();
  int32_t rate() const;
  void set_rate(int32_t value);
  private:
  int32_t _internal_rate() const;
  void _internal_set_rate(int32_t value);
  public:
 
  // optional bool ack_requested = 5;
  bool has_ack_requested() const;
  private:
  bool _internal_has_ack_requested() const;
  public:
  void clear_ack_requested();
  bool ack_requested() const;
  void set_ack_requested(bool value);
  private:
  bool _internal_ack_requested() const;
  void _internal_set_ack_requested(bool value);
  public:
 
  // optional uint32 frame_start = 6 [(.dccl.field) = {
  bool has_frame_start() const;
  private:
  bool _internal_has_frame_start() const;
  public:
  void clear_frame_start();
  uint32_t frame_start() const;
  void set_frame_start(uint32_t value);
  private:
  uint32_t _internal_frame_start() const;
  void _internal_set_frame_start(uint32_t value);
  public:
 
  // optional int32 acked_frame = 7 [(.dccl.field) = {
  bool has_acked_frame() const;
  private:
  bool _internal_has_acked_frame() const;
  public:
  void clear_acked_frame();
  int32_t acked_frame() const;
  void set_acked_frame(int32_t value);
  private:
  int32_t _internal_acked_frame() const;
  void _internal_set_acked_frame(int32_t value);
  public:
 
  // required .goby.acomms.protobuf.ModemTransmission.TransmissionType type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::goby::acomms::protobuf::ModemTransmission_TransmissionType type() const;
  void set_type(::goby::acomms::protobuf::ModemTransmission_TransmissionType value);
  private:
  ::goby::acomms::protobuf::ModemTransmission_TransmissionType _internal_type() const;
  void _internal_set_type(::goby::acomms::protobuf::ModemTransmission_TransmissionType value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.iridium.protobuf.IridiumHeader)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t src_;
    int32_t dest_;
    int32_t rate_;
    bool ack_requested_;
    uint32_t frame_start_;
    int32_t acked_frame_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto;
};
// ===================================================================
 
static const int kConfigFieldNumber = 1381;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::acomms::protobuf::DriverConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::goby::acomms::iridium::protobuf::Config >, 11, false >
  config;
static const int kTransmissionFieldNumber = 1381;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::acomms::protobuf::ModemTransmission,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::goby::acomms::iridium::protobuf::Transmission >, 11, false >
  transmission;
static const int kReportFieldNumber = 1381;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::goby::acomms::protobuf::ModemReport,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::goby::acomms::iridium::protobuf::Report >, 11, false >
  report;
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Config_Remote
 
// required string iridium_number = 1;
inline bool Config_Remote::_internal_has_iridium_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Config_Remote::has_iridium_number() const {
  return _internal_has_iridium_number();
}
inline void Config_Remote::clear_iridium_number() {
  _impl_.iridium_number_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Config_Remote::iridium_number() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.Remote.iridium_number)
  return _internal_iridium_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Config_Remote::set_iridium_number(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.iridium_number_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.Remote.iridium_number)
}
inline std::string* Config_Remote::mutable_iridium_number() {
  std::string* _s = _internal_mutable_iridium_number();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.Config.Remote.iridium_number)
  return _s;
}
inline const std::string& Config_Remote::_internal_iridium_number() const {
  return _impl_.iridium_number_.Get();
}
inline void Config_Remote::_internal_set_iridium_number(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.iridium_number_.Set(value, GetArenaForAllocation());
}
inline std::string* Config_Remote::_internal_mutable_iridium_number() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.iridium_number_.Mutable(GetArenaForAllocation());
}
inline std::string* Config_Remote::release_iridium_number() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.Config.Remote.iridium_number)
  if (!_internal_has_iridium_number()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.iridium_number_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.iridium_number_.IsDefault()) {
    _impl_.iridium_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Config_Remote::set_allocated_iridium_number(std::string* iridium_number) {
  if (iridium_number != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.iridium_number_.SetAllocated(iridium_number, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.iridium_number_.IsDefault()) {
    _impl_.iridium_number_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.Config.Remote.iridium_number)
}
 
// required int32 modem_id = 2;
inline bool Config_Remote::_internal_has_modem_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Config_Remote::has_modem_id() const {
  return _internal_has_modem_id();
}
inline void Config_Remote::clear_modem_id() {
  _impl_.modem_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Config_Remote::_internal_modem_id() const {
  return _impl_.modem_id_;
}
inline int32_t Config_Remote::modem_id() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.Remote.modem_id)
  return _internal_modem_id();
}
inline void Config_Remote::_internal_set_modem_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.modem_id_ = value;
}
inline void Config_Remote::set_modem_id(int32_t value) {
  _internal_set_modem_id(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.Remote.modem_id)
}
 
// -------------------------------------------------------------------
 
// Config
 
// optional .goby.acomms.iridium.protobuf.Config.Remote remote = 1;
inline bool Config::_internal_has_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remote_ != nullptr);
  return value;
}
inline bool Config::has_remote() const {
  return _internal_has_remote();
}
inline void Config::clear_remote() {
  if (_impl_.remote_ != nullptr) _impl_.remote_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::iridium::protobuf::Config_Remote& Config::_internal_remote() const {
  const ::goby::acomms::iridium::protobuf::Config_Remote* p = _impl_.remote_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::iridium::protobuf::Config_Remote&>(
      ::goby::acomms::iridium::protobuf::_Config_Remote_default_instance_);
}
inline const ::goby::acomms::iridium::protobuf::Config_Remote& Config::remote() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.remote)
  return _internal_remote();
}
inline void Config::unsafe_arena_set_allocated_remote(
    ::goby::acomms::iridium::protobuf::Config_Remote* remote) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remote_);
  }
  _impl_.remote_ = remote;
  if (remote) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.iridium.protobuf.Config.remote)
}
inline ::goby::acomms::iridium::protobuf::Config_Remote* Config::release_remote() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::iridium::protobuf::Config_Remote* temp = _impl_.remote_;
  _impl_.remote_ = 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::iridium::protobuf::Config_Remote* Config::unsafe_arena_release_remote() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.Config.remote)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::iridium::protobuf::Config_Remote* temp = _impl_.remote_;
  _impl_.remote_ = nullptr;
  return temp;
}
inline ::goby::acomms::iridium::protobuf::Config_Remote* Config::_internal_mutable_remote() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.remote_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::iridium::protobuf::Config_Remote>(GetArenaForAllocation());
    _impl_.remote_ = p;
  }
  return _impl_.remote_;
}
inline ::goby::acomms::iridium::protobuf::Config_Remote* Config::mutable_remote() {
  ::goby::acomms::iridium::protobuf::Config_Remote* _msg = _internal_mutable_remote();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.Config.remote)
  return _msg;
}
inline void Config::set_allocated_remote(::goby::acomms::iridium::protobuf::Config_Remote* remote) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remote_;
  }
  if (remote) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remote);
    if (message_arena != submessage_arena) {
      remote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remote, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.remote_ = remote;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.Config.remote)
}
 
// optional uint32 max_frame_size = 2 [default = 1500];
inline bool Config::_internal_has_max_frame_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Config::has_max_frame_size() const {
  return _internal_has_max_frame_size();
}
inline void Config::clear_max_frame_size() {
  _impl_.max_frame_size_ = 1500u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Config::_internal_max_frame_size() const {
  return _impl_.max_frame_size_;
}
inline uint32_t Config::max_frame_size() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.max_frame_size)
  return _internal_max_frame_size();
}
inline void Config::_internal_set_max_frame_size(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.max_frame_size_ = value;
}
inline void Config::set_max_frame_size(uint32_t value) {
  _internal_set_max_frame_size(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.max_frame_size)
}
 
// optional int32 target_bit_rate = 3 [default = 2400];
inline bool Config::_internal_has_target_bit_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Config::has_target_bit_rate() const {
  return _internal_has_target_bit_rate();
}
inline void Config::clear_target_bit_rate() {
  _impl_.target_bit_rate_ = 2400;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t Config::_internal_target_bit_rate() const {
  return _impl_.target_bit_rate_;
}
inline int32_t Config::target_bit_rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.target_bit_rate)
  return _internal_target_bit_rate();
}
inline void Config::_internal_set_target_bit_rate(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.target_bit_rate_ = value;
}
inline void Config::set_target_bit_rate(int32_t value) {
  _internal_set_target_bit_rate(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.target_bit_rate)
}
 
// repeated string config = 4;
inline int Config::_internal_config_size() const {
  return _impl_.config_.size();
}
inline int Config::config_size() const {
  return _internal_config_size();
}
inline void Config::clear_config() {
  _impl_.config_.Clear();
}
inline std::string* Config::add_config() {
  std::string* _s = _internal_add_config();
  // @@protoc_insertion_point(field_add_mutable:goby.acomms.iridium.protobuf.Config.config)
  return _s;
}
inline const std::string& Config::_internal_config(int index) const {
  return _impl_.config_.Get(index);
}
inline const std::string& Config::config(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.config)
  return _internal_config(index);
}
inline std::string* Config::mutable_config(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.Config.config)
  return _impl_.config_.Mutable(index);
}
inline void Config::set_config(int index, const std::string& value) {
  _impl_.config_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::set_config(int index, std::string&& value) {
  _impl_.config_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::set_config(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.config_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::set_config(int index, const char* value, size_t size) {
  _impl_.config_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:goby.acomms.iridium.protobuf.Config.config)
}
inline std::string* Config::_internal_add_config() {
  return _impl_.config_.Add();
}
inline void Config::add_config(const std::string& value) {
  _impl_.config_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::add_config(std::string&& value) {
  _impl_.config_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::add_config(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.config_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:goby.acomms.iridium.protobuf.Config.config)
}
inline void Config::add_config(const char* value, size_t size) {
  _impl_.config_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:goby.acomms.iridium.protobuf.Config.config)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Config::config() const {
  // @@protoc_insertion_point(field_list:goby.acomms.iridium.protobuf.Config.config)
  return _impl_.config_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Config::mutable_config() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.iridium.protobuf.Config.config)
  return &_impl_.config_;
}
 
// optional int32 dial_attempts = 5 [default = 3];
inline bool Config::_internal_has_dial_attempts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Config::has_dial_attempts() const {
  return _internal_has_dial_attempts();
}
inline void Config::clear_dial_attempts() {
  _impl_.dial_attempts_ = 3;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t Config::_internal_dial_attempts() const {
  return _impl_.dial_attempts_;
}
inline int32_t Config::dial_attempts() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.dial_attempts)
  return _internal_dial_attempts();
}
inline void Config::_internal_set_dial_attempts(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.dial_attempts_ = value;
}
inline void Config::set_dial_attempts(int32_t value) {
  _internal_set_dial_attempts(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.dial_attempts)
}
 
// optional int32 debug_client_port = 6;
inline bool Config::_internal_has_debug_client_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Config::has_debug_client_port() const {
  return _internal_has_debug_client_port();
}
inline void Config::clear_debug_client_port() {
  _impl_.debug_client_port_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Config::_internal_debug_client_port() const {
  return _impl_.debug_client_port_;
}
inline int32_t Config::debug_client_port() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.debug_client_port)
  return _internal_debug_client_port();
}
inline void Config::_internal_set_debug_client_port(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.debug_client_port_ = value;
}
inline void Config::set_debug_client_port(int32_t value) {
  _internal_set_debug_client_port(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.debug_client_port)
}
 
// optional int32 hangup_seconds_after_empty = 8 [default = 30];
inline bool Config::_internal_has_hangup_seconds_after_empty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Config::has_hangup_seconds_after_empty() const {
  return _internal_has_hangup_seconds_after_empty();
}
inline void Config::clear_hangup_seconds_after_empty() {
  _impl_.hangup_seconds_after_empty_ = 30;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t Config::_internal_hangup_seconds_after_empty() const {
  return _impl_.hangup_seconds_after_empty_;
}
inline int32_t Config::hangup_seconds_after_empty() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.hangup_seconds_after_empty)
  return _internal_hangup_seconds_after_empty();
}
inline void Config::_internal_set_hangup_seconds_after_empty(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.hangup_seconds_after_empty_ = value;
}
inline void Config::set_hangup_seconds_after_empty(int32_t value) {
  _internal_set_hangup_seconds_after_empty(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.hangup_seconds_after_empty)
}
 
// optional int32 start_timeout = 9 [default = 20];
inline bool Config::_internal_has_start_timeout() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Config::has_start_timeout() const {
  return _internal_has_start_timeout();
}
inline void Config::clear_start_timeout() {
  _impl_.start_timeout_ = 20;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t Config::_internal_start_timeout() const {
  return _impl_.start_timeout_;
}
inline int32_t Config::start_timeout() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.start_timeout)
  return _internal_start_timeout();
}
inline void Config::_internal_set_start_timeout(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.start_timeout_ = value;
}
inline void Config::set_start_timeout(int32_t value) {
  _internal_set_start_timeout(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.start_timeout)
}
 
// optional bool use_dtr = 10 [default = false];
inline bool Config::_internal_has_use_dtr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Config::has_use_dtr() const {
  return _internal_has_use_dtr();
}
inline void Config::clear_use_dtr() {
  _impl_.use_dtr_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool Config::_internal_use_dtr() const {
  return _impl_.use_dtr_;
}
inline bool Config::use_dtr() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.use_dtr)
  return _internal_use_dtr();
}
inline void Config::_internal_set_use_dtr(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.use_dtr_ = value;
}
inline void Config::set_use_dtr(bool value) {
  _internal_set_use_dtr(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.use_dtr)
}
 
// optional int32 handshake_hangup_seconds = 12 [default = 5];
inline bool Config::_internal_has_handshake_hangup_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Config::has_handshake_hangup_seconds() const {
  return _internal_has_handshake_hangup_seconds();
}
inline void Config::clear_handshake_hangup_seconds() {
  _impl_.handshake_hangup_seconds_ = 5;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t Config::_internal_handshake_hangup_seconds() const {
  return _impl_.handshake_hangup_seconds_;
}
inline int32_t Config::handshake_hangup_seconds() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.handshake_hangup_seconds)
  return _internal_handshake_hangup_seconds();
}
inline void Config::_internal_set_handshake_hangup_seconds(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.handshake_hangup_seconds_ = value;
}
inline void Config::set_handshake_hangup_seconds(int32_t value) {
  _internal_set_handshake_hangup_seconds(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.handshake_hangup_seconds)
}
 
// optional bool enable_sbdring_automatic_registration = 13 [default = true];
inline bool Config::_internal_has_enable_sbdring_automatic_registration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Config::has_enable_sbdring_automatic_registration() const {
  return _internal_has_enable_sbdring_automatic_registration();
}
inline void Config::clear_enable_sbdring_automatic_registration() {
  _impl_.enable_sbdring_automatic_registration_ = true;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool Config::_internal_enable_sbdring_automatic_registration() const {
  return _impl_.enable_sbdring_automatic_registration_;
}
inline bool Config::enable_sbdring_automatic_registration() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.enable_sbdring_automatic_registration)
  return _internal_enable_sbdring_automatic_registration();
}
inline void Config::_internal_set_enable_sbdring_automatic_registration(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.enable_sbdring_automatic_registration_ = value;
}
inline void Config::set_enable_sbdring_automatic_registration(bool value) {
  _internal_set_enable_sbdring_automatic_registration(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.enable_sbdring_automatic_registration)
}
 
// optional .goby.acomms.iridium.protobuf.DeviceType device = 14 [default = DEVICE_VOICE_ENABLED_ISU];
inline bool Config::_internal_has_device() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Config::has_device() const {
  return _internal_has_device();
}
inline void Config::clear_device() {
  _impl_.device_ = 1;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline ::goby::acomms::iridium::protobuf::DeviceType Config::_internal_device() const {
  return static_cast< ::goby::acomms::iridium::protobuf::DeviceType >(_impl_.device_);
}
inline ::goby::acomms::iridium::protobuf::DeviceType Config::device() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Config.device)
  return _internal_device();
}
inline void Config::_internal_set_device(::goby::acomms::iridium::protobuf::DeviceType value) {
  assert(::goby::acomms::iridium::protobuf::DeviceType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.device_ = value;
}
inline void Config::set_device(::goby::acomms::iridium::protobuf::DeviceType value) {
  _internal_set_device(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Config.device)
}
 
// -------------------------------------------------------------------
 
// RockblockReceive
 
// optional int32 momsn = 1;
inline bool RockblockReceive::_internal_has_momsn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool RockblockReceive::has_momsn() const {
  return _internal_has_momsn();
}
inline void RockblockReceive::clear_momsn() {
  _impl_.momsn_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t RockblockReceive::_internal_momsn() const {
  return _impl_.momsn_;
}
inline int32_t RockblockReceive::momsn() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.momsn)
  return _internal_momsn();
}
inline void RockblockReceive::_internal_set_momsn(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.momsn_ = value;
}
inline void RockblockReceive::set_momsn(int32_t value) {
  _internal_set_momsn(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.momsn)
}
 
// optional double iridium_latitude = 2 [(.dccl.field) = {
inline bool RockblockReceive::_internal_has_iridium_latitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RockblockReceive::has_iridium_latitude() const {
  return _internal_has_iridium_latitude();
}
inline void RockblockReceive::clear_iridium_latitude() {
  _impl_.iridium_latitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline double RockblockReceive::_internal_iridium_latitude() const {
  return _impl_.iridium_latitude_;
}
inline double RockblockReceive::iridium_latitude() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.iridium_latitude)
  return _internal_iridium_latitude();
}
inline void RockblockReceive::_internal_set_iridium_latitude(double value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.iridium_latitude_ = value;
}
inline void RockblockReceive::set_iridium_latitude(double value) {
  _internal_set_iridium_latitude(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.iridium_latitude)
}
 
// optional double iridium_longitude = 3 [(.dccl.field) = {
inline bool RockblockReceive::_internal_has_iridium_longitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RockblockReceive::has_iridium_longitude() const {
  return _internal_has_iridium_longitude();
}
inline void RockblockReceive::clear_iridium_longitude() {
  _impl_.iridium_longitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double RockblockReceive::_internal_iridium_longitude() const {
  return _impl_.iridium_longitude_;
}
inline double RockblockReceive::iridium_longitude() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.iridium_longitude)
  return _internal_iridium_longitude();
}
inline void RockblockReceive::_internal_set_iridium_longitude(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.iridium_longitude_ = value;
}
inline void RockblockReceive::set_iridium_longitude(double value) {
  _internal_set_iridium_longitude(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.iridium_longitude)
}
 
// optional double iridium_cep_radius = 4 [(.dccl.field) = {
inline bool RockblockReceive::_internal_has_iridium_cep_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool RockblockReceive::has_iridium_cep_radius() const {
  return _internal_has_iridium_cep_radius();
}
inline void RockblockReceive::clear_iridium_cep_radius() {
  _impl_.iridium_cep_radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline double RockblockReceive::_internal_iridium_cep_radius() const {
  return _impl_.iridium_cep_radius_;
}
inline double RockblockReceive::iridium_cep_radius() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.iridium_cep_radius)
  return _internal_iridium_cep_radius();
}
inline void RockblockReceive::_internal_set_iridium_cep_radius(double value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.iridium_cep_radius_ = value;
}
inline void RockblockReceive::set_iridium_cep_radius(double value) {
  _internal_set_iridium_cep_radius(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.iridium_cep_radius)
}
 
// optional int32 serial = 5;
inline bool RockblockReceive::_internal_has_serial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool RockblockReceive::has_serial() const {
  return _internal_has_serial();
}
inline void RockblockReceive::clear_serial() {
  _impl_.serial_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t RockblockReceive::_internal_serial() const {
  return _impl_.serial_;
}
inline int32_t RockblockReceive::serial() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.serial)
  return _internal_serial();
}
inline void RockblockReceive::_internal_set_serial(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.serial_ = value;
}
inline void RockblockReceive::set_serial(int32_t value) {
  _internal_set_serial(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.serial)
}
 
// optional string imei = 6;
inline bool RockblockReceive::_internal_has_imei() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RockblockReceive::has_imei() const {
  return _internal_has_imei();
}
inline void RockblockReceive::clear_imei() {
  _impl_.imei_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& RockblockReceive::imei() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.imei)
  return _internal_imei();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RockblockReceive::set_imei(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.imei_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.imei)
}
inline std::string* RockblockReceive::mutable_imei() {
  std::string* _s = _internal_mutable_imei();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.RockblockReceive.imei)
  return _s;
}
inline const std::string& RockblockReceive::_internal_imei() const {
  return _impl_.imei_.Get();
}
inline void RockblockReceive::_internal_set_imei(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.imei_.Set(value, GetArenaForAllocation());
}
inline std::string* RockblockReceive::_internal_mutable_imei() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.imei_.Mutable(GetArenaForAllocation());
}
inline std::string* RockblockReceive::release_imei() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.RockblockReceive.imei)
  if (!_internal_has_imei()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.imei_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.imei_.IsDefault()) {
    _impl_.imei_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void RockblockReceive::set_allocated_imei(std::string* imei) {
  if (imei != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.imei_.SetAllocated(imei, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.imei_.IsDefault()) {
    _impl_.imei_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.RockblockReceive.imei)
}
 
// optional string device_type = 7;
inline bool RockblockReceive::_internal_has_device_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RockblockReceive::has_device_type() const {
  return _internal_has_device_type();
}
inline void RockblockReceive::clear_device_type() {
  _impl_.device_type_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& RockblockReceive::device_type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.device_type)
  return _internal_device_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RockblockReceive::set_device_type(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.device_type)
}
inline std::string* RockblockReceive::mutable_device_type() {
  std::string* _s = _internal_mutable_device_type();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.RockblockReceive.device_type)
  return _s;
}
inline const std::string& RockblockReceive::_internal_device_type() const {
  return _impl_.device_type_.Get();
}
inline void RockblockReceive::_internal_set_device_type(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.device_type_.Set(value, GetArenaForAllocation());
}
inline std::string* RockblockReceive::_internal_mutable_device_type() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.device_type_.Mutable(GetArenaForAllocation());
}
inline std::string* RockblockReceive::release_device_type() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.RockblockReceive.device_type)
  if (!_internal_has_device_type()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.device_type_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_type_.IsDefault()) {
    _impl_.device_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void RockblockReceive::set_allocated_device_type(std::string* device_type) {
  if (device_type != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_type_.IsDefault()) {
    _impl_.device_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.RockblockReceive.device_type)
}
 
// optional string transmit_time = 8;
inline bool RockblockReceive::_internal_has_transmit_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RockblockReceive::has_transmit_time() const {
  return _internal_has_transmit_time();
}
inline void RockblockReceive::clear_transmit_time() {
  _impl_.transmit_time_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& RockblockReceive::transmit_time() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.transmit_time)
  return _internal_transmit_time();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RockblockReceive::set_transmit_time(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.transmit_time_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.transmit_time)
}
inline std::string* RockblockReceive::mutable_transmit_time() {
  std::string* _s = _internal_mutable_transmit_time();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.RockblockReceive.transmit_time)
  return _s;
}
inline const std::string& RockblockReceive::_internal_transmit_time() const {
  return _impl_.transmit_time_.Get();
}
inline void RockblockReceive::_internal_set_transmit_time(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.transmit_time_.Set(value, GetArenaForAllocation());
}
inline std::string* RockblockReceive::_internal_mutable_transmit_time() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.transmit_time_.Mutable(GetArenaForAllocation());
}
inline std::string* RockblockReceive::release_transmit_time() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.RockblockReceive.transmit_time)
  if (!_internal_has_transmit_time()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.transmit_time_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.transmit_time_.IsDefault()) {
    _impl_.transmit_time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void RockblockReceive::set_allocated_transmit_time(std::string* transmit_time) {
  if (transmit_time != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.transmit_time_.SetAllocated(transmit_time, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.transmit_time_.IsDefault()) {
    _impl_.transmit_time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.RockblockReceive.transmit_time)
}
 
// optional bool jwt_verified = 9 [default = false];
inline bool RockblockReceive::_internal_has_jwt_verified() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool RockblockReceive::has_jwt_verified() const {
  return _internal_has_jwt_verified();
}
inline void RockblockReceive::clear_jwt_verified() {
  _impl_.jwt_verified_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool RockblockReceive::_internal_jwt_verified() const {
  return _impl_.jwt_verified_;
}
inline bool RockblockReceive::jwt_verified() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockReceive.jwt_verified)
  return _internal_jwt_verified();
}
inline void RockblockReceive::_internal_set_jwt_verified(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.jwt_verified_ = value;
}
inline void RockblockReceive::set_jwt_verified(bool value) {
  _internal_set_jwt_verified(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockReceive.jwt_verified)
}
 
// -------------------------------------------------------------------
 
// RockblockTransmit
 
// required bool success = 1;
inline bool RockblockTransmit::_internal_has_success() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RockblockTransmit::has_success() const {
  return _internal_has_success();
}
inline void RockblockTransmit::clear_success() {
  _impl_.success_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool RockblockTransmit::_internal_success() const {
  return _impl_.success_;
}
inline bool RockblockTransmit::success() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockTransmit.success)
  return _internal_success();
}
inline void RockblockTransmit::_internal_set_success(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.success_ = value;
}
inline void RockblockTransmit::set_success(bool value) {
  _internal_set_success(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockTransmit.success)
}
 
// optional int32 mt_id = 2;
inline bool RockblockTransmit::_internal_has_mt_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RockblockTransmit::has_mt_id() const {
  return _internal_has_mt_id();
}
inline void RockblockTransmit::clear_mt_id() {
  _impl_.mt_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t RockblockTransmit::_internal_mt_id() const {
  return _impl_.mt_id_;
}
inline int32_t RockblockTransmit::mt_id() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockTransmit.mt_id)
  return _internal_mt_id();
}
inline void RockblockTransmit::_internal_set_mt_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mt_id_ = value;
}
inline void RockblockTransmit::set_mt_id(int32_t value) {
  _internal_set_mt_id(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockTransmit.mt_id)
}
 
// optional .goby.acomms.iridium.protobuf.RockblockTransmit.Error error = 10 [default = ERROR_SUCCESS];
inline bool RockblockTransmit::_internal_has_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RockblockTransmit::has_error() const {
  return _internal_has_error();
}
inline void RockblockTransmit::clear_error() {
  _impl_.error_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::acomms::iridium::protobuf::RockblockTransmit_Error RockblockTransmit::_internal_error() const {
  return static_cast< ::goby::acomms::iridium::protobuf::RockblockTransmit_Error >(_impl_.error_);
}
inline ::goby::acomms::iridium::protobuf::RockblockTransmit_Error RockblockTransmit::error() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.RockblockTransmit.error)
  return _internal_error();
}
inline void RockblockTransmit::_internal_set_error(::goby::acomms::iridium::protobuf::RockblockTransmit_Error value) {
  assert(::goby::acomms::iridium::protobuf::RockblockTransmit_Error_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.error_ = value;
}
inline void RockblockTransmit::set_error(::goby::acomms::iridium::protobuf::RockblockTransmit_Error value) {
  _internal_set_error(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.RockblockTransmit.error)
}
 
// -------------------------------------------------------------------
 
// Transmission
 
// optional bool if_no_data_do_mailbox_check = 1 [default = true];
inline bool Transmission::_internal_has_if_no_data_do_mailbox_check() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Transmission::has_if_no_data_do_mailbox_check() const {
  return _internal_has_if_no_data_do_mailbox_check();
}
inline void Transmission::clear_if_no_data_do_mailbox_check() {
  _impl_.if_no_data_do_mailbox_check_ = true;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool Transmission::_internal_if_no_data_do_mailbox_check() const {
  return _impl_.if_no_data_do_mailbox_check_;
}
inline bool Transmission::if_no_data_do_mailbox_check() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Transmission.if_no_data_do_mailbox_check)
  return _internal_if_no_data_do_mailbox_check();
}
inline void Transmission::_internal_set_if_no_data_do_mailbox_check(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.if_no_data_do_mailbox_check_ = value;
}
inline void Transmission::set_if_no_data_do_mailbox_check(bool value) {
  _internal_set_if_no_data_do_mailbox_check(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Transmission.if_no_data_do_mailbox_check)
}
 
// optional .goby.acomms.iridium.protobuf.RockblockReceive rockblock_rx = 10;
inline bool Transmission::_internal_has_rockblock_rx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rockblock_rx_ != nullptr);
  return value;
}
inline bool Transmission::has_rockblock_rx() const {
  return _internal_has_rockblock_rx();
}
inline void Transmission::clear_rockblock_rx() {
  if (_impl_.rockblock_rx_ != nullptr) _impl_.rockblock_rx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::iridium::protobuf::RockblockReceive& Transmission::_internal_rockblock_rx() const {
  const ::goby::acomms::iridium::protobuf::RockblockReceive* p = _impl_.rockblock_rx_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::iridium::protobuf::RockblockReceive&>(
      ::goby::acomms::iridium::protobuf::_RockblockReceive_default_instance_);
}
inline const ::goby::acomms::iridium::protobuf::RockblockReceive& Transmission::rockblock_rx() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Transmission.rockblock_rx)
  return _internal_rockblock_rx();
}
inline void Transmission::unsafe_arena_set_allocated_rockblock_rx(
    ::goby::acomms::iridium::protobuf::RockblockReceive* rockblock_rx) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rockblock_rx_);
  }
  _impl_.rockblock_rx_ = rockblock_rx;
  if (rockblock_rx) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.iridium.protobuf.Transmission.rockblock_rx)
}
inline ::goby::acomms::iridium::protobuf::RockblockReceive* Transmission::release_rockblock_rx() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::iridium::protobuf::RockblockReceive* temp = _impl_.rockblock_rx_;
  _impl_.rockblock_rx_ = 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::iridium::protobuf::RockblockReceive* Transmission::unsafe_arena_release_rockblock_rx() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.Transmission.rockblock_rx)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::iridium::protobuf::RockblockReceive* temp = _impl_.rockblock_rx_;
  _impl_.rockblock_rx_ = nullptr;
  return temp;
}
inline ::goby::acomms::iridium::protobuf::RockblockReceive* Transmission::_internal_mutable_rockblock_rx() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.rockblock_rx_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::iridium::protobuf::RockblockReceive>(GetArenaForAllocation());
    _impl_.rockblock_rx_ = p;
  }
  return _impl_.rockblock_rx_;
}
inline ::goby::acomms::iridium::protobuf::RockblockReceive* Transmission::mutable_rockblock_rx() {
  ::goby::acomms::iridium::protobuf::RockblockReceive* _msg = _internal_mutable_rockblock_rx();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.Transmission.rockblock_rx)
  return _msg;
}
inline void Transmission::set_allocated_rockblock_rx(::goby::acomms::iridium::protobuf::RockblockReceive* rockblock_rx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.rockblock_rx_;
  }
  if (rockblock_rx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rockblock_rx);
    if (message_arena != submessage_arena) {
      rockblock_rx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rockblock_rx, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.rockblock_rx_ = rockblock_rx;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.Transmission.rockblock_rx)
}
 
// optional .goby.acomms.iridium.protobuf.RockblockTransmit rockblock_tx = 11;
inline bool Transmission::_internal_has_rockblock_tx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.rockblock_tx_ != nullptr);
  return value;
}
inline bool Transmission::has_rockblock_tx() const {
  return _internal_has_rockblock_tx();
}
inline void Transmission::clear_rockblock_tx() {
  if (_impl_.rockblock_tx_ != nullptr) _impl_.rockblock_tx_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::acomms::iridium::protobuf::RockblockTransmit& Transmission::_internal_rockblock_tx() const {
  const ::goby::acomms::iridium::protobuf::RockblockTransmit* p = _impl_.rockblock_tx_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::iridium::protobuf::RockblockTransmit&>(
      ::goby::acomms::iridium::protobuf::_RockblockTransmit_default_instance_);
}
inline const ::goby::acomms::iridium::protobuf::RockblockTransmit& Transmission::rockblock_tx() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Transmission.rockblock_tx)
  return _internal_rockblock_tx();
}
inline void Transmission::unsafe_arena_set_allocated_rockblock_tx(
    ::goby::acomms::iridium::protobuf::RockblockTransmit* rockblock_tx) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rockblock_tx_);
  }
  _impl_.rockblock_tx_ = rockblock_tx;
  if (rockblock_tx) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.iridium.protobuf.Transmission.rockblock_tx)
}
inline ::goby::acomms::iridium::protobuf::RockblockTransmit* Transmission::release_rockblock_tx() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::iridium::protobuf::RockblockTransmit* temp = _impl_.rockblock_tx_;
  _impl_.rockblock_tx_ = 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::iridium::protobuf::RockblockTransmit* Transmission::unsafe_arena_release_rockblock_tx() {
  // @@protoc_insertion_point(field_release:goby.acomms.iridium.protobuf.Transmission.rockblock_tx)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::iridium::protobuf::RockblockTransmit* temp = _impl_.rockblock_tx_;
  _impl_.rockblock_tx_ = nullptr;
  return temp;
}
inline ::goby::acomms::iridium::protobuf::RockblockTransmit* Transmission::_internal_mutable_rockblock_tx() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.rockblock_tx_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::iridium::protobuf::RockblockTransmit>(GetArenaForAllocation());
    _impl_.rockblock_tx_ = p;
  }
  return _impl_.rockblock_tx_;
}
inline ::goby::acomms::iridium::protobuf::RockblockTransmit* Transmission::mutable_rockblock_tx() {
  ::goby::acomms::iridium::protobuf::RockblockTransmit* _msg = _internal_mutable_rockblock_tx();
  // @@protoc_insertion_point(field_mutable:goby.acomms.iridium.protobuf.Transmission.rockblock_tx)
  return _msg;
}
inline void Transmission::set_allocated_rockblock_tx(::goby::acomms::iridium::protobuf::RockblockTransmit* rockblock_tx) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.rockblock_tx_;
  }
  if (rockblock_tx) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rockblock_tx);
    if (message_arena != submessage_arena) {
      rockblock_tx = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rockblock_tx, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.rockblock_tx_ = rockblock_tx;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.iridium.protobuf.Transmission.rockblock_tx)
}
 
// -------------------------------------------------------------------
 
// Report
 
// optional .goby.acomms.iridium.protobuf.Report.RSSI rssi = 1;
inline bool Report::_internal_has_rssi() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Report::has_rssi() const {
  return _internal_has_rssi();
}
inline void Report::clear_rssi() {
  _impl_.rssi_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::goby::acomms::iridium::protobuf::Report_RSSI Report::_internal_rssi() const {
  return static_cast< ::goby::acomms::iridium::protobuf::Report_RSSI >(_impl_.rssi_);
}
inline ::goby::acomms::iridium::protobuf::Report_RSSI Report::rssi() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.Report.rssi)
  return _internal_rssi();
}
inline void Report::_internal_set_rssi(::goby::acomms::iridium::protobuf::Report_RSSI value) {
  assert(::goby::acomms::iridium::protobuf::Report_RSSI_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rssi_ = value;
}
inline void Report::set_rssi(::goby::acomms::iridium::protobuf::Report_RSSI value) {
  _internal_set_rssi(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.Report.rssi)
}
 
// -------------------------------------------------------------------
 
// IridiumHeader
 
// required int32 src = 1 [(.dccl.field) = {
inline bool IridiumHeader::_internal_has_src() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IridiumHeader::has_src() const {
  return _internal_has_src();
}
inline void IridiumHeader::clear_src() {
  _impl_.src_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t IridiumHeader::_internal_src() const {
  return _impl_.src_;
}
inline int32_t IridiumHeader::src() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.src)
  return _internal_src();
}
inline void IridiumHeader::_internal_set_src(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.src_ = value;
}
inline void IridiumHeader::set_src(int32_t value) {
  _internal_set_src(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.src)
}
 
// required int32 dest = 2 [(.dccl.field) = {
inline bool IridiumHeader::_internal_has_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IridiumHeader::has_dest() const {
  return _internal_has_dest();
}
inline void IridiumHeader::clear_dest() {
  _impl_.dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t IridiumHeader::_internal_dest() const {
  return _impl_.dest_;
}
inline int32_t IridiumHeader::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.dest)
  return _internal_dest();
}
inline void IridiumHeader::_internal_set_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dest_ = value;
}
inline void IridiumHeader::set_dest(int32_t value) {
  _internal_set_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.dest)
}
 
// optional int32 rate = 3 [(.dccl.field) = {
inline bool IridiumHeader::_internal_has_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool IridiumHeader::has_rate() const {
  return _internal_has_rate();
}
inline void IridiumHeader::clear_rate() {
  _impl_.rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t IridiumHeader::_internal_rate() const {
  return _impl_.rate_;
}
inline int32_t IridiumHeader::rate() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.rate)
  return _internal_rate();
}
inline void IridiumHeader::_internal_set_rate(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.rate_ = value;
}
inline void IridiumHeader::set_rate(int32_t value) {
  _internal_set_rate(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.rate)
}
 
// required .goby.acomms.protobuf.ModemTransmission.TransmissionType type = 4;
inline bool IridiumHeader::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool IridiumHeader::has_type() const {
  return _internal_has_type();
}
inline void IridiumHeader::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::goby::acomms::protobuf::ModemTransmission_TransmissionType IridiumHeader::_internal_type() const {
  return static_cast< ::goby::acomms::protobuf::ModemTransmission_TransmissionType >(_impl_.type_);
}
inline ::goby::acomms::protobuf::ModemTransmission_TransmissionType IridiumHeader::type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.type)
  return _internal_type();
}
inline void IridiumHeader::_internal_set_type(::goby::acomms::protobuf::ModemTransmission_TransmissionType value) {
  assert(::goby::acomms::protobuf::ModemTransmission_TransmissionType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.type_ = value;
}
inline void IridiumHeader::set_type(::goby::acomms::protobuf::ModemTransmission_TransmissionType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.type)
}
 
// optional bool ack_requested = 5;
inline bool IridiumHeader::_internal_has_ack_requested() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool IridiumHeader::has_ack_requested() const {
  return _internal_has_ack_requested();
}
inline void IridiumHeader::clear_ack_requested() {
  _impl_.ack_requested_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool IridiumHeader::_internal_ack_requested() const {
  return _impl_.ack_requested_;
}
inline bool IridiumHeader::ack_requested() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.ack_requested)
  return _internal_ack_requested();
}
inline void IridiumHeader::_internal_set_ack_requested(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ack_requested_ = value;
}
inline void IridiumHeader::set_ack_requested(bool value) {
  _internal_set_ack_requested(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.ack_requested)
}
 
// optional uint32 frame_start = 6 [(.dccl.field) = {
inline bool IridiumHeader::_internal_has_frame_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool IridiumHeader::has_frame_start() const {
  return _internal_has_frame_start();
}
inline void IridiumHeader::clear_frame_start() {
  _impl_.frame_start_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t IridiumHeader::_internal_frame_start() const {
  return _impl_.frame_start_;
}
inline uint32_t IridiumHeader::frame_start() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.frame_start)
  return _internal_frame_start();
}
inline void IridiumHeader::_internal_set_frame_start(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.frame_start_ = value;
}
inline void IridiumHeader::set_frame_start(uint32_t value) {
  _internal_set_frame_start(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.frame_start)
}
 
// optional int32 acked_frame = 7 [(.dccl.field) = {
inline bool IridiumHeader::_internal_has_acked_frame() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool IridiumHeader::has_acked_frame() const {
  return _internal_has_acked_frame();
}
inline void IridiumHeader::clear_acked_frame() {
  _impl_.acked_frame_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t IridiumHeader::_internal_acked_frame() const {
  return _impl_.acked_frame_;
}
inline int32_t IridiumHeader::acked_frame() const {
  // @@protoc_insertion_point(field_get:goby.acomms.iridium.protobuf.IridiumHeader.acked_frame)
  return _internal_acked_frame();
}
inline void IridiumHeader::_internal_set_acked_frame(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.acked_frame_ = value;
}
inline void IridiumHeader::set_acked_frame(int32_t value) {
  _internal_set_acked_frame(value);
  // @@protoc_insertion_point(field_set:goby.acomms.iridium.protobuf.IridiumHeader.acked_frame)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace iridium
}  // namespace acomms
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::acomms::iridium::protobuf::RockblockTransmit_Error> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::iridium::protobuf::RockblockTransmit_Error>() {
  return ::goby::acomms::iridium::protobuf::RockblockTransmit_Error_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::iridium::protobuf::Report_RSSI> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::iridium::protobuf::Report_RSSI>() {
  return ::goby::acomms::iridium::protobuf::Report_RSSI_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::iridium::protobuf::DeviceType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::iridium::protobuf::DeviceType>() {
  return ::goby::acomms::iridium::protobuf::DeviceType_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2firidium_5fdriver_2eproto