network_header.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/acomms/protobuf/network_header.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2facomms_2fprotobuf_2fnetwork_5fheader_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_bases.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 "dccl/option_extensions.pb.h"
#include "dccl/arithmetic/protobuf/arithmetic_extensions.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2facomms_2fprotobuf_2fnetwork_5fheader_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_2fnetwork_5fheader_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
namespace goby {
namespace acomms {
namespace protobuf {
class ICMPHeader;
struct ICMPHeaderDefaultTypeInternal;
extern ICMPHeaderDefaultTypeInternal _ICMPHeader_default_instance_;
class IPGatewayICMPControl;
struct IPGatewayICMPControlDefaultTypeInternal;
extern IPGatewayICMPControlDefaultTypeInternal _IPGatewayICMPControl_default_instance_;
class IPGatewayICMPControl_QueueReport;
struct IPGatewayICMPControl_QueueReportDefaultTypeInternal;
extern IPGatewayICMPControl_QueueReportDefaultTypeInternal _IPGatewayICMPControl_QueueReport_default_instance_;
class IPGatewayICMPControl_QueueReport_SubQueue;
struct IPGatewayICMPControl_QueueReport_SubQueueDefaultTypeInternal;
extern IPGatewayICMPControl_QueueReport_SubQueueDefaultTypeInternal _IPGatewayICMPControl_QueueReport_SubQueue_default_instance_;
class IPv4Header;
struct IPv4HeaderDefaultTypeInternal;
extern IPv4HeaderDefaultTypeInternal _IPv4Header_default_instance_;
class IPv4Header_FlagsFragOffset;
struct IPv4Header_FlagsFragOffsetDefaultTypeInternal;
extern IPv4Header_FlagsFragOffsetDefaultTypeInternal _IPv4Header_FlagsFragOffset_default_instance_;
class NetworkHeader;
struct NetworkHeaderDefaultTypeInternal;
extern NetworkHeaderDefaultTypeInternal _NetworkHeader_default_instance_;
class NetworkHeader_ICMPHeader;
struct NetworkHeader_ICMPHeaderDefaultTypeInternal;
extern NetworkHeader_ICMPHeaderDefaultTypeInternal _NetworkHeader_ICMPHeader_default_instance_;
class NetworkHeader_SCTPHeader;
struct NetworkHeader_SCTPHeaderDefaultTypeInternal;
extern NetworkHeader_SCTPHeaderDefaultTypeInternal _NetworkHeader_SCTPHeader_default_instance_;
class NetworkHeader_UDPHeader;
struct NetworkHeader_UDPHeaderDefaultTypeInternal;
extern NetworkHeader_UDPHeaderDefaultTypeInternal _NetworkHeader_UDPHeader_default_instance_;
class UDPHeader;
struct UDPHeaderDefaultTypeInternal;
extern UDPHeaderDefaultTypeInternal _UDPHeader_default_instance_;
}  // namespace protobuf
}  // namespace acomms
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::acomms::protobuf::ICMPHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::ICMPHeader>(Arena*);
template<> ::goby::acomms::protobuf::IPGatewayICMPControl* Arena::CreateMaybeMessage<::goby::acomms::protobuf::IPGatewayICMPControl>(Arena*);
template<> ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* Arena::CreateMaybeMessage<::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport>(Arena*);
template<> ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* Arena::CreateMaybeMessage<::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue>(Arena*);
template<> ::goby::acomms::protobuf::IPv4Header* Arena::CreateMaybeMessage<::goby::acomms::protobuf::IPv4Header>(Arena*);
template<> ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* Arena::CreateMaybeMessage<::goby::acomms::protobuf::IPv4Header_FlagsFragOffset>(Arena*);
template<> ::goby::acomms::protobuf::NetworkHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::NetworkHeader>(Arena*);
template<> ::goby::acomms::protobuf::NetworkHeader_ICMPHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::NetworkHeader_ICMPHeader>(Arena*);
template<> ::goby::acomms::protobuf::NetworkHeader_SCTPHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::NetworkHeader_SCTPHeader>(Arena*);
template<> ::goby::acomms::protobuf::NetworkHeader_UDPHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::NetworkHeader_UDPHeader>(Arena*);
template<> ::goby::acomms::protobuf::UDPHeader* Arena::CreateMaybeMessage<::goby::acomms::protobuf::UDPHeader>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace acomms {
namespace protobuf {
 
enum NetworkHeader_Protocol : int {
  NetworkHeader_Protocol_ICMP = 1,
  NetworkHeader_Protocol_UDP = 17,
  NetworkHeader_Protocol_SCTP = 132
};
bool NetworkHeader_Protocol_IsValid(int value);
constexpr NetworkHeader_Protocol NetworkHeader_Protocol_Protocol_MIN = NetworkHeader_Protocol_ICMP;
constexpr NetworkHeader_Protocol NetworkHeader_Protocol_Protocol_MAX = NetworkHeader_Protocol_SCTP;
constexpr int NetworkHeader_Protocol_Protocol_ARRAYSIZE = NetworkHeader_Protocol_Protocol_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NetworkHeader_Protocol_descriptor();
template<typename T>
inline const std::string& NetworkHeader_Protocol_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NetworkHeader_Protocol>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NetworkHeader_Protocol_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NetworkHeader_Protocol_descriptor(), enum_t_value);
}
inline bool NetworkHeader_Protocol_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NetworkHeader_Protocol* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NetworkHeader_Protocol>(
    NetworkHeader_Protocol_descriptor(), name, value);
}
enum IPGatewayICMPControl_MessageType : int {
  IPGatewayICMPControl_MessageType_QUEUE_REPORT = 1
};
bool IPGatewayICMPControl_MessageType_IsValid(int value);
constexpr IPGatewayICMPControl_MessageType IPGatewayICMPControl_MessageType_MessageType_MIN = IPGatewayICMPControl_MessageType_QUEUE_REPORT;
constexpr IPGatewayICMPControl_MessageType IPGatewayICMPControl_MessageType_MessageType_MAX = IPGatewayICMPControl_MessageType_QUEUE_REPORT;
constexpr int IPGatewayICMPControl_MessageType_MessageType_ARRAYSIZE = IPGatewayICMPControl_MessageType_MessageType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IPGatewayICMPControl_MessageType_descriptor();
template<typename T>
inline const std::string& IPGatewayICMPControl_MessageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, IPGatewayICMPControl_MessageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function IPGatewayICMPControl_MessageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    IPGatewayICMPControl_MessageType_descriptor(), enum_t_value);
}
inline bool IPGatewayICMPControl_MessageType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IPGatewayICMPControl_MessageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IPGatewayICMPControl_MessageType>(
    IPGatewayICMPControl_MessageType_descriptor(), name, value);
}
// ===================================================================
 
class NetworkHeader_UDPHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.NetworkHeader.UDPHeader) */ {
 public:
  inline NetworkHeader_UDPHeader() : NetworkHeader_UDPHeader(nullptr) {}
  ~NetworkHeader_UDPHeader() override;
  explicit PROTOBUF_CONSTEXPR NetworkHeader_UDPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NetworkHeader_UDPHeader(const NetworkHeader_UDPHeader& from);
  NetworkHeader_UDPHeader(NetworkHeader_UDPHeader&& from) noexcept
    : NetworkHeader_UDPHeader() {
    *this = ::std::move(from);
  }
 
  inline NetworkHeader_UDPHeader& operator=(const NetworkHeader_UDPHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetworkHeader_UDPHeader& operator=(NetworkHeader_UDPHeader&& 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 NetworkHeader_UDPHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetworkHeader_UDPHeader* internal_default_instance() {
    return reinterpret_cast<const NetworkHeader_UDPHeader*>(
               &_NetworkHeader_UDPHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(NetworkHeader_UDPHeader& a, NetworkHeader_UDPHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(NetworkHeader_UDPHeader* 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(NetworkHeader_UDPHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NetworkHeader_UDPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetworkHeader_UDPHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NetworkHeader_UDPHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NetworkHeader_UDPHeader& from) {
    NetworkHeader_UDPHeader::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(NetworkHeader_UDPHeader* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.NetworkHeader.UDPHeader";
  }
  protected:
  explicit NetworkHeader_UDPHeader(::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 {
    kSrcdestPortFieldNumber = 1,
  };
  // repeated uint32 srcdest_port = 1 [(.dccl.field) = {
  int srcdest_port_size() const;
  private:
  int _internal_srcdest_port_size() const;
  public:
  void clear_srcdest_port();
  private:
  uint32_t _internal_srcdest_port(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_srcdest_port() const;
  void _internal_add_srcdest_port(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_srcdest_port();
  public:
  uint32_t srcdest_port(int index) const;
  void set_srcdest_port(int index, uint32_t value);
  void add_srcdest_port(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      srcdest_port() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_srcdest_port();
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.NetworkHeader.UDPHeader)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > srcdest_port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class NetworkHeader_ICMPHeader final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.NetworkHeader.ICMPHeader) */ {
 public:
  inline NetworkHeader_ICMPHeader() : NetworkHeader_ICMPHeader(nullptr) {}
  explicit PROTOBUF_CONSTEXPR NetworkHeader_ICMPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NetworkHeader_ICMPHeader(const NetworkHeader_ICMPHeader& from);
  NetworkHeader_ICMPHeader(NetworkHeader_ICMPHeader&& from) noexcept
    : NetworkHeader_ICMPHeader() {
    *this = ::std::move(from);
  }
 
  inline NetworkHeader_ICMPHeader& operator=(const NetworkHeader_ICMPHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetworkHeader_ICMPHeader& operator=(NetworkHeader_ICMPHeader&& 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 NetworkHeader_ICMPHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetworkHeader_ICMPHeader* internal_default_instance() {
    return reinterpret_cast<const NetworkHeader_ICMPHeader*>(
               &_NetworkHeader_ICMPHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(NetworkHeader_ICMPHeader& a, NetworkHeader_ICMPHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(NetworkHeader_ICMPHeader* 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(NetworkHeader_ICMPHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NetworkHeader_ICMPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetworkHeader_ICMPHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const NetworkHeader_ICMPHeader& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const NetworkHeader_ICMPHeader& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.NetworkHeader.ICMPHeader";
  }
  protected:
  explicit NetworkHeader_ICMPHeader(::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 -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.NetworkHeader.ICMPHeader)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class NetworkHeader_SCTPHeader final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.NetworkHeader.SCTPHeader) */ {
 public:
  inline NetworkHeader_SCTPHeader() : NetworkHeader_SCTPHeader(nullptr) {}
  explicit PROTOBUF_CONSTEXPR NetworkHeader_SCTPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NetworkHeader_SCTPHeader(const NetworkHeader_SCTPHeader& from);
  NetworkHeader_SCTPHeader(NetworkHeader_SCTPHeader&& from) noexcept
    : NetworkHeader_SCTPHeader() {
    *this = ::std::move(from);
  }
 
  inline NetworkHeader_SCTPHeader& operator=(const NetworkHeader_SCTPHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetworkHeader_SCTPHeader& operator=(NetworkHeader_SCTPHeader&& 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 NetworkHeader_SCTPHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetworkHeader_SCTPHeader* internal_default_instance() {
    return reinterpret_cast<const NetworkHeader_SCTPHeader*>(
               &_NetworkHeader_SCTPHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(NetworkHeader_SCTPHeader& a, NetworkHeader_SCTPHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(NetworkHeader_SCTPHeader* 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(NetworkHeader_SCTPHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NetworkHeader_SCTPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetworkHeader_SCTPHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const NetworkHeader_SCTPHeader& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const NetworkHeader_SCTPHeader& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.NetworkHeader.SCTPHeader";
  }
  protected:
  explicit NetworkHeader_SCTPHeader(::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 -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.NetworkHeader.SCTPHeader)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class NetworkHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.NetworkHeader) */ {
 public:
  inline NetworkHeader() : NetworkHeader(nullptr) {}
  ~NetworkHeader() override;
  explicit PROTOBUF_CONSTEXPR NetworkHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NetworkHeader(const NetworkHeader& from);
  NetworkHeader(NetworkHeader&& from) noexcept
    : NetworkHeader() {
    *this = ::std::move(from);
  }
 
  inline NetworkHeader& operator=(const NetworkHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetworkHeader& operator=(NetworkHeader&& 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 NetworkHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const NetworkHeader* internal_default_instance() {
    return reinterpret_cast<const NetworkHeader*>(
               &_NetworkHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(NetworkHeader& a, NetworkHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(NetworkHeader* 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(NetworkHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NetworkHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NetworkHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NetworkHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NetworkHeader& from) {
    NetworkHeader::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(NetworkHeader* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.NetworkHeader";
  }
  protected:
  explicit NetworkHeader(::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 NetworkHeader_UDPHeader UDPHeader;
  typedef NetworkHeader_ICMPHeader ICMPHeader;
  typedef NetworkHeader_SCTPHeader SCTPHeader;
 
  typedef NetworkHeader_Protocol Protocol;
  static constexpr Protocol ICMP =
    NetworkHeader_Protocol_ICMP;
  static constexpr Protocol UDP =
    NetworkHeader_Protocol_UDP;
  static constexpr Protocol SCTP =
    NetworkHeader_Protocol_SCTP;
  static inline bool Protocol_IsValid(int value) {
    return NetworkHeader_Protocol_IsValid(value);
  }
  static constexpr Protocol Protocol_MIN =
    NetworkHeader_Protocol_Protocol_MIN;
  static constexpr Protocol Protocol_MAX =
    NetworkHeader_Protocol_Protocol_MAX;
  static constexpr int Protocol_ARRAYSIZE =
    NetworkHeader_Protocol_Protocol_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Protocol_descriptor() {
    return NetworkHeader_Protocol_descriptor();
  }
  template<typename T>
  static inline const std::string& Protocol_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Protocol>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Protocol_Name.");
    return NetworkHeader_Protocol_Name(enum_t_value);
  }
  static inline bool Protocol_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Protocol* value) {
    return NetworkHeader_Protocol_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kUdpFieldNumber = 20,
    kSrcdestAddrFieldNumber = 10,
    kProtocolFieldNumber = 1,
  };
  // required .goby.acomms.protobuf.NetworkHeader.UDPHeader udp = 20;
  bool has_udp() const;
  private:
  bool _internal_has_udp() const;
  public:
  void clear_udp();
  const ::goby::acomms::protobuf::NetworkHeader_UDPHeader& udp() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::NetworkHeader_UDPHeader* release_udp();
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* mutable_udp();
  void set_allocated_udp(::goby::acomms::protobuf::NetworkHeader_UDPHeader* udp);
  private:
  const ::goby::acomms::protobuf::NetworkHeader_UDPHeader& _internal_udp() const;
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* _internal_mutable_udp();
  public:
  void unsafe_arena_set_allocated_udp(
      ::goby::acomms::protobuf::NetworkHeader_UDPHeader* udp);
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* unsafe_arena_release_udp();
 
  // required uint32 srcdest_addr = 10 [(.dccl.field) = {
  bool has_srcdest_addr() const;
  private:
  bool _internal_has_srcdest_addr() const;
  public:
  void clear_srcdest_addr();
  uint32_t srcdest_addr() const;
  void set_srcdest_addr(uint32_t value);
  private:
  uint32_t _internal_srcdest_addr() const;
  void _internal_set_srcdest_addr(uint32_t value);
  public:
 
  // required .goby.acomms.protobuf.NetworkHeader.Protocol protocol = 1;
  bool has_protocol() const;
  private:
  bool _internal_has_protocol() const;
  public:
  void clear_protocol();
  ::goby::acomms::protobuf::NetworkHeader_Protocol protocol() const;
  void set_protocol(::goby::acomms::protobuf::NetworkHeader_Protocol value);
  private:
  ::goby::acomms::protobuf::NetworkHeader_Protocol _internal_protocol() const;
  void _internal_set_protocol(::goby::acomms::protobuf::NetworkHeader_Protocol value);
  public:
 
  enum DCCLParameters { DCCL_ID = 61440,  DCCL_MAX_BYTES = 8 };
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.NetworkHeader)
 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_;
    ::goby::acomms::protobuf::NetworkHeader_UDPHeader* udp_;
    uint32_t srcdest_addr_;
    int protocol_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class IPv4Header_FlagsFragOffset final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.IPv4Header.FlagsFragOffset) */ {
 public:
  inline IPv4Header_FlagsFragOffset() : IPv4Header_FlagsFragOffset(nullptr) {}
  ~IPv4Header_FlagsFragOffset() override;
  explicit PROTOBUF_CONSTEXPR IPv4Header_FlagsFragOffset(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IPv4Header_FlagsFragOffset(const IPv4Header_FlagsFragOffset& from);
  IPv4Header_FlagsFragOffset(IPv4Header_FlagsFragOffset&& from) noexcept
    : IPv4Header_FlagsFragOffset() {
    *this = ::std::move(from);
  }
 
  inline IPv4Header_FlagsFragOffset& operator=(const IPv4Header_FlagsFragOffset& from) {
    CopyFrom(from);
    return *this;
  }
  inline IPv4Header_FlagsFragOffset& operator=(IPv4Header_FlagsFragOffset&& 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 IPv4Header_FlagsFragOffset& default_instance() {
    return *internal_default_instance();
  }
  static inline const IPv4Header_FlagsFragOffset* internal_default_instance() {
    return reinterpret_cast<const IPv4Header_FlagsFragOffset*>(
               &_IPv4Header_FlagsFragOffset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(IPv4Header_FlagsFragOffset& a, IPv4Header_FlagsFragOffset& b) {
    a.Swap(&b);
  }
  inline void Swap(IPv4Header_FlagsFragOffset* 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(IPv4Header_FlagsFragOffset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IPv4Header_FlagsFragOffset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IPv4Header_FlagsFragOffset>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IPv4Header_FlagsFragOffset& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IPv4Header_FlagsFragOffset& from) {
    IPv4Header_FlagsFragOffset::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(IPv4Header_FlagsFragOffset* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.IPv4Header.FlagsFragOffset";
  }
  protected:
  explicit IPv4Header_FlagsFragOffset(::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 {
    kDontFragmentFieldNumber = 1,
    kMoreFragmentsFieldNumber = 2,
    kFragmentOffsetFieldNumber = 3,
  };
  // required bool dont_fragment = 1;
  bool has_dont_fragment() const;
  private:
  bool _internal_has_dont_fragment() const;
  public:
  void clear_dont_fragment();
  bool dont_fragment() const;
  void set_dont_fragment(bool value);
  private:
  bool _internal_dont_fragment() const;
  void _internal_set_dont_fragment(bool value);
  public:
 
  // required bool more_fragments = 2;
  bool has_more_fragments() const;
  private:
  bool _internal_has_more_fragments() const;
  public:
  void clear_more_fragments();
  bool more_fragments() const;
  void set_more_fragments(bool value);
  private:
  bool _internal_more_fragments() const;
  void _internal_set_more_fragments(bool value);
  public:
 
  // required uint32 fragment_offset = 3;
  bool has_fragment_offset() const;
  private:
  bool _internal_has_fragment_offset() const;
  public:
  void clear_fragment_offset();
  uint32_t fragment_offset() const;
  void set_fragment_offset(uint32_t value);
  private:
  uint32_t _internal_fragment_offset() const;
  void _internal_set_fragment_offset(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.IPv4Header.FlagsFragOffset)
 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_;
    bool dont_fragment_;
    bool more_fragments_;
    uint32_t fragment_offset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class IPv4Header final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.IPv4Header) */ {
 public:
  inline IPv4Header() : IPv4Header(nullptr) {}
  ~IPv4Header() override;
  explicit PROTOBUF_CONSTEXPR IPv4Header(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IPv4Header(const IPv4Header& from);
  IPv4Header(IPv4Header&& from) noexcept
    : IPv4Header() {
    *this = ::std::move(from);
  }
 
  inline IPv4Header& operator=(const IPv4Header& from) {
    CopyFrom(from);
    return *this;
  }
  inline IPv4Header& operator=(IPv4Header&& 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 IPv4Header& default_instance() {
    return *internal_default_instance();
  }
  static inline const IPv4Header* internal_default_instance() {
    return reinterpret_cast<const IPv4Header*>(
               &_IPv4Header_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(IPv4Header& a, IPv4Header& b) {
    a.Swap(&b);
  }
  inline void Swap(IPv4Header* 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(IPv4Header* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IPv4Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IPv4Header>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IPv4Header& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IPv4Header& from) {
    IPv4Header::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(IPv4Header* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.IPv4Header";
  }
  protected:
  explicit IPv4Header(::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 IPv4Header_FlagsFragOffset FlagsFragOffset;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSourceIpAddressFieldNumber = 11,
    kDestIpAddressFieldNumber = 12,
    kFlagsFragOffsetFieldNumber = 7,
    kVersionFieldNumber = 1,
    kIhlFieldNumber = 2,
    kDscpFieldNumber = 3,
    kEcnFieldNumber = 4,
    kTotalLengthFieldNumber = 5,
    kIdentificationFieldNumber = 6,
    kTtlFieldNumber = 8,
    kProtocolFieldNumber = 9,
    kHeaderChecksumFieldNumber = 10,
  };
  // required string source_ip_address = 11 [(.dccl.field) = {
  bool has_source_ip_address() const;
  private:
  bool _internal_has_source_ip_address() const;
  public:
  void clear_source_ip_address();
  const std::string& source_ip_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source_ip_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source_ip_address();
  PROTOBUF_NODISCARD std::string* release_source_ip_address();
  void set_allocated_source_ip_address(std::string* source_ip_address);
  private:
  const std::string& _internal_source_ip_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_ip_address(const std::string& value);
  std::string* _internal_mutable_source_ip_address();
  public:
 
  // required string dest_ip_address = 12 [(.dccl.field) = {
  bool has_dest_ip_address() const;
  private:
  bool _internal_has_dest_ip_address() const;
  public:
  void clear_dest_ip_address();
  const std::string& dest_ip_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dest_ip_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dest_ip_address();
  PROTOBUF_NODISCARD std::string* release_dest_ip_address();
  void set_allocated_dest_ip_address(std::string* dest_ip_address);
  private:
  const std::string& _internal_dest_ip_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dest_ip_address(const std::string& value);
  std::string* _internal_mutable_dest_ip_address();
  public:
 
  // required .goby.acomms.protobuf.IPv4Header.FlagsFragOffset flags_frag_offset = 7 [(.dccl.field) = {
  bool has_flags_frag_offset() const;
  private:
  bool _internal_has_flags_frag_offset() const;
  public:
  void clear_flags_frag_offset();
  const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset& flags_frag_offset() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* release_flags_frag_offset();
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* mutable_flags_frag_offset();
  void set_allocated_flags_frag_offset(::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* flags_frag_offset);
  private:
  const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset& _internal_flags_frag_offset() const;
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* _internal_mutable_flags_frag_offset();
  public:
  void unsafe_arena_set_allocated_flags_frag_offset(
      ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* flags_frag_offset);
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* unsafe_arena_release_flags_frag_offset();
 
  // required uint32 version = 1 [(.dccl.field) = {
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  uint32_t version() const;
  void set_version(uint32_t value);
  private:
  uint32_t _internal_version() const;
  void _internal_set_version(uint32_t value);
  public:
 
  // required uint32 ihl = 2 [(.dccl.field) = {
  bool has_ihl() const;
  private:
  bool _internal_has_ihl() const;
  public:
  void clear_ihl();
  uint32_t ihl() const;
  void set_ihl(uint32_t value);
  private:
  uint32_t _internal_ihl() const;
  void _internal_set_ihl(uint32_t value);
  public:
 
  // required uint32 dscp = 3 [(.dccl.field) = {
  bool has_dscp() const;
  private:
  bool _internal_has_dscp() const;
  public:
  void clear_dscp();
  uint32_t dscp() const;
  void set_dscp(uint32_t value);
  private:
  uint32_t _internal_dscp() const;
  void _internal_set_dscp(uint32_t value);
  public:
 
  // required uint32 ecn = 4 [(.dccl.field) = {
  bool has_ecn() const;
  private:
  bool _internal_has_ecn() const;
  public:
  void clear_ecn();
  uint32_t ecn() const;
  void set_ecn(uint32_t value);
  private:
  uint32_t _internal_ecn() const;
  void _internal_set_ecn(uint32_t value);
  public:
 
  // required uint32 total_length = 5 [(.dccl.field) = {
  bool has_total_length() const;
  private:
  bool _internal_has_total_length() const;
  public:
  void clear_total_length();
  uint32_t total_length() const;
  void set_total_length(uint32_t value);
  private:
  uint32_t _internal_total_length() const;
  void _internal_set_total_length(uint32_t value);
  public:
 
  // required uint32 identification = 6 [(.dccl.field) = {
  bool has_identification() const;
  private:
  bool _internal_has_identification() const;
  public:
  void clear_identification();
  uint32_t identification() const;
  void set_identification(uint32_t value);
  private:
  uint32_t _internal_identification() const;
  void _internal_set_identification(uint32_t value);
  public:
 
  // required uint32 ttl = 8 [(.dccl.field) = {
  bool has_ttl() const;
  private:
  bool _internal_has_ttl() const;
  public:
  void clear_ttl();
  uint32_t ttl() const;
  void set_ttl(uint32_t value);
  private:
  uint32_t _internal_ttl() const;
  void _internal_set_ttl(uint32_t value);
  public:
 
  // required uint32 protocol = 9 [(.dccl.field) = {
  bool has_protocol() const;
  private:
  bool _internal_has_protocol() const;
  public:
  void clear_protocol();
  uint32_t protocol() const;
  void set_protocol(uint32_t value);
  private:
  uint32_t _internal_protocol() const;
  void _internal_set_protocol(uint32_t value);
  public:
 
  // required uint32 header_checksum = 10 [(.dccl.field) = {
  bool has_header_checksum() const;
  private:
  bool _internal_has_header_checksum() const;
  public:
  void clear_header_checksum();
  uint32_t header_checksum() const;
  void set_header_checksum(uint32_t value);
  private:
  uint32_t _internal_header_checksum() const;
  void _internal_set_header_checksum(uint32_t value);
  public:
 
  enum DCCLParameters { DCCL_ID = 61441,  DCCL_MAX_BYTES = 60 };
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.IPv4Header)
 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 source_ip_address_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dest_ip_address_;
    ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* flags_frag_offset_;
    uint32_t version_;
    uint32_t ihl_;
    uint32_t dscp_;
    uint32_t ecn_;
    uint32_t total_length_;
    uint32_t identification_;
    uint32_t ttl_;
    uint32_t protocol_;
    uint32_t header_checksum_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class UDPHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.UDPHeader) */ {
 public:
  inline UDPHeader() : UDPHeader(nullptr) {}
  ~UDPHeader() override;
  explicit PROTOBUF_CONSTEXPR UDPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  UDPHeader(const UDPHeader& from);
  UDPHeader(UDPHeader&& from) noexcept
    : UDPHeader() {
    *this = ::std::move(from);
  }
 
  inline UDPHeader& operator=(const UDPHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline UDPHeader& operator=(UDPHeader&& 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 UDPHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const UDPHeader* internal_default_instance() {
    return reinterpret_cast<const UDPHeader*>(
               &_UDPHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(UDPHeader& a, UDPHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(UDPHeader* 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(UDPHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  UDPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UDPHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UDPHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const UDPHeader& from) {
    UDPHeader::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(UDPHeader* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.UDPHeader";
  }
  protected:
  explicit UDPHeader(::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 {
    kSourcePortFieldNumber = 1,
    kDestPortFieldNumber = 2,
    kLengthFieldNumber = 3,
    kChecksumFieldNumber = 4,
  };
  // required uint32 source_port = 1 [(.dccl.field) = {
  bool has_source_port() const;
  private:
  bool _internal_has_source_port() const;
  public:
  void clear_source_port();
  uint32_t source_port() const;
  void set_source_port(uint32_t value);
  private:
  uint32_t _internal_source_port() const;
  void _internal_set_source_port(uint32_t value);
  public:
 
  // required uint32 dest_port = 2 [(.dccl.field) = {
  bool has_dest_port() const;
  private:
  bool _internal_has_dest_port() const;
  public:
  void clear_dest_port();
  uint32_t dest_port() const;
  void set_dest_port(uint32_t value);
  private:
  uint32_t _internal_dest_port() const;
  void _internal_set_dest_port(uint32_t value);
  public:
 
  // required uint32 length = 3 [(.dccl.field) = {
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  uint32_t length() const;
  void set_length(uint32_t value);
  private:
  uint32_t _internal_length() const;
  void _internal_set_length(uint32_t value);
  public:
 
  // required uint32 checksum = 4 [(.dccl.field) = {
  bool has_checksum() const;
  private:
  bool _internal_has_checksum() const;
  public:
  void clear_checksum();
  uint32_t checksum() const;
  void set_checksum(uint32_t value);
  private:
  uint32_t _internal_checksum() const;
  void _internal_set_checksum(uint32_t value);
  public:
 
  enum DCCLParameters { DCCL_ID = 61442,  DCCL_MAX_BYTES = 8 };
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.UDPHeader)
 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_;
    uint32_t source_port_;
    uint32_t dest_port_;
    uint32_t length_;
    uint32_t checksum_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class ICMPHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.ICMPHeader) */ {
 public:
  inline ICMPHeader() : ICMPHeader(nullptr) {}
  ~ICMPHeader() override;
  explicit PROTOBUF_CONSTEXPR ICMPHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  ICMPHeader(const ICMPHeader& from);
  ICMPHeader(ICMPHeader&& from) noexcept
    : ICMPHeader() {
    *this = ::std::move(from);
  }
 
  inline ICMPHeader& operator=(const ICMPHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline ICMPHeader& operator=(ICMPHeader&& 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 ICMPHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const ICMPHeader* internal_default_instance() {
    return reinterpret_cast<const ICMPHeader*>(
               &_ICMPHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(ICMPHeader& a, ICMPHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(ICMPHeader* 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(ICMPHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  ICMPHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ICMPHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ICMPHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ICMPHeader& from) {
    ICMPHeader::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(ICMPHeader* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.ICMPHeader";
  }
  protected:
  explicit ICMPHeader(::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 {
    kTypeFieldNumber = 1,
    kCodeFieldNumber = 2,
    kChecksumFieldNumber = 3,
    kShort1FieldNumber = 4,
    kShort2FieldNumber = 5,
  };
  // required uint32 type = 1 [(.dccl.field) = {
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  uint32_t type() const;
  void set_type(uint32_t value);
  private:
  uint32_t _internal_type() const;
  void _internal_set_type(uint32_t value);
  public:
 
  // required uint32 code = 2 [(.dccl.field) = {
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  uint32_t code() const;
  void set_code(uint32_t value);
  private:
  uint32_t _internal_code() const;
  void _internal_set_code(uint32_t value);
  public:
 
  // required uint32 checksum = 3 [(.dccl.field) = {
  bool has_checksum() const;
  private:
  bool _internal_has_checksum() const;
  public:
  void clear_checksum();
  uint32_t checksum() const;
  void set_checksum(uint32_t value);
  private:
  uint32_t _internal_checksum() const;
  void _internal_set_checksum(uint32_t value);
  public:
 
  // required uint32 short1 = 4 [(.dccl.field) = {
  bool has_short1() const;
  private:
  bool _internal_has_short1() const;
  public:
  void clear_short1();
  uint32_t short1() const;
  void set_short1(uint32_t value);
  private:
  uint32_t _internal_short1() const;
  void _internal_set_short1(uint32_t value);
  public:
 
  // required uint32 short2 = 5 [(.dccl.field) = {
  bool has_short2() const;
  private:
  bool _internal_has_short2() const;
  public:
  void clear_short2();
  uint32_t short2() const;
  void set_short2(uint32_t value);
  private:
  uint32_t _internal_short2() const;
  void _internal_set_short2(uint32_t value);
  public:
 
  enum DCCLParameters { DCCL_ID = 61443,  DCCL_MAX_BYTES = 8 };
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.ICMPHeader)
 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_;
    uint32_t type_;
    uint32_t code_;
    uint32_t checksum_;
    uint32_t short1_;
    uint32_t short2_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class IPGatewayICMPControl_QueueReport_SubQueue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue) */ {
 public:
  inline IPGatewayICMPControl_QueueReport_SubQueue() : IPGatewayICMPControl_QueueReport_SubQueue(nullptr) {}
  ~IPGatewayICMPControl_QueueReport_SubQueue() override;
  explicit PROTOBUF_CONSTEXPR IPGatewayICMPControl_QueueReport_SubQueue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IPGatewayICMPControl_QueueReport_SubQueue(const IPGatewayICMPControl_QueueReport_SubQueue& from);
  IPGatewayICMPControl_QueueReport_SubQueue(IPGatewayICMPControl_QueueReport_SubQueue&& from) noexcept
    : IPGatewayICMPControl_QueueReport_SubQueue() {
    *this = ::std::move(from);
  }
 
  inline IPGatewayICMPControl_QueueReport_SubQueue& operator=(const IPGatewayICMPControl_QueueReport_SubQueue& from) {
    CopyFrom(from);
    return *this;
  }
  inline IPGatewayICMPControl_QueueReport_SubQueue& operator=(IPGatewayICMPControl_QueueReport_SubQueue&& 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 IPGatewayICMPControl_QueueReport_SubQueue& default_instance() {
    return *internal_default_instance();
  }
  static inline const IPGatewayICMPControl_QueueReport_SubQueue* internal_default_instance() {
    return reinterpret_cast<const IPGatewayICMPControl_QueueReport_SubQueue*>(
               &_IPGatewayICMPControl_QueueReport_SubQueue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(IPGatewayICMPControl_QueueReport_SubQueue& a, IPGatewayICMPControl_QueueReport_SubQueue& b) {
    a.Swap(&b);
  }
  inline void Swap(IPGatewayICMPControl_QueueReport_SubQueue* 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(IPGatewayICMPControl_QueueReport_SubQueue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IPGatewayICMPControl_QueueReport_SubQueue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IPGatewayICMPControl_QueueReport_SubQueue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IPGatewayICMPControl_QueueReport_SubQueue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IPGatewayICMPControl_QueueReport_SubQueue& from) {
    IPGatewayICMPControl_QueueReport_SubQueue::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(IPGatewayICMPControl_QueueReport_SubQueue* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue";
  }
  protected:
  explicit IPGatewayICMPControl_QueueReport_SubQueue(::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 {
    kDestFieldNumber = 1,
    kSizeFieldNumber = 2,
  };
  // required int32 dest = 1;
  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:
 
  // required int32 size = 2;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  int32_t size() const;
  void set_size(int32_t value);
  private:
  int32_t _internal_size() const;
  void _internal_set_size(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue)
 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 dest_;
    int32_t size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class IPGatewayICMPControl_QueueReport final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport) */ {
 public:
  inline IPGatewayICMPControl_QueueReport() : IPGatewayICMPControl_QueueReport(nullptr) {}
  ~IPGatewayICMPControl_QueueReport() override;
  explicit PROTOBUF_CONSTEXPR IPGatewayICMPControl_QueueReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IPGatewayICMPControl_QueueReport(const IPGatewayICMPControl_QueueReport& from);
  IPGatewayICMPControl_QueueReport(IPGatewayICMPControl_QueueReport&& from) noexcept
    : IPGatewayICMPControl_QueueReport() {
    *this = ::std::move(from);
  }
 
  inline IPGatewayICMPControl_QueueReport& operator=(const IPGatewayICMPControl_QueueReport& from) {
    CopyFrom(from);
    return *this;
  }
  inline IPGatewayICMPControl_QueueReport& operator=(IPGatewayICMPControl_QueueReport&& 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 IPGatewayICMPControl_QueueReport& default_instance() {
    return *internal_default_instance();
  }
  static inline const IPGatewayICMPControl_QueueReport* internal_default_instance() {
    return reinterpret_cast<const IPGatewayICMPControl_QueueReport*>(
               &_IPGatewayICMPControl_QueueReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;
 
  friend void swap(IPGatewayICMPControl_QueueReport& a, IPGatewayICMPControl_QueueReport& b) {
    a.Swap(&b);
  }
  inline void Swap(IPGatewayICMPControl_QueueReport* 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(IPGatewayICMPControl_QueueReport* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IPGatewayICMPControl_QueueReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IPGatewayICMPControl_QueueReport>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IPGatewayICMPControl_QueueReport& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IPGatewayICMPControl_QueueReport& from) {
    IPGatewayICMPControl_QueueReport::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(IPGatewayICMPControl_QueueReport* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.IPGatewayICMPControl.QueueReport";
  }
  protected:
  explicit IPGatewayICMPControl_QueueReport(::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 IPGatewayICMPControl_QueueReport_SubQueue SubQueue;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kQueueFieldNumber = 1,
  };
  // repeated .goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue queue = 1;
  int queue_size() const;
  private:
  int _internal_queue_size() const;
  public:
  void clear_queue();
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* mutable_queue(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue >*
      mutable_queue();
  private:
  const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue& _internal_queue(int index) const;
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* _internal_add_queue();
  public:
  const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue& queue(int index) const;
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* add_queue();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue >&
      queue() const;
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue > queue_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// -------------------------------------------------------------------
 
class IPGatewayICMPControl final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.acomms.protobuf.IPGatewayICMPControl) */ {
 public:
  inline IPGatewayICMPControl() : IPGatewayICMPControl(nullptr) {}
  ~IPGatewayICMPControl() override;
  explicit PROTOBUF_CONSTEXPR IPGatewayICMPControl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IPGatewayICMPControl(const IPGatewayICMPControl& from);
  IPGatewayICMPControl(IPGatewayICMPControl&& from) noexcept
    : IPGatewayICMPControl() {
    *this = ::std::move(from);
  }
 
  inline IPGatewayICMPControl& operator=(const IPGatewayICMPControl& from) {
    CopyFrom(from);
    return *this;
  }
  inline IPGatewayICMPControl& operator=(IPGatewayICMPControl&& 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 IPGatewayICMPControl& default_instance() {
    return *internal_default_instance();
  }
  static inline const IPGatewayICMPControl* internal_default_instance() {
    return reinterpret_cast<const IPGatewayICMPControl*>(
               &_IPGatewayICMPControl_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;
 
  friend void swap(IPGatewayICMPControl& a, IPGatewayICMPControl& b) {
    a.Swap(&b);
  }
  inline void Swap(IPGatewayICMPControl* 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(IPGatewayICMPControl* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IPGatewayICMPControl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IPGatewayICMPControl>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IPGatewayICMPControl& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IPGatewayICMPControl& from) {
    IPGatewayICMPControl::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(IPGatewayICMPControl* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.acomms.protobuf.IPGatewayICMPControl";
  }
  protected:
  explicit IPGatewayICMPControl(::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 IPGatewayICMPControl_QueueReport QueueReport;
 
  typedef IPGatewayICMPControl_MessageType MessageType;
  static constexpr MessageType QUEUE_REPORT =
    IPGatewayICMPControl_MessageType_QUEUE_REPORT;
  static inline bool MessageType_IsValid(int value) {
    return IPGatewayICMPControl_MessageType_IsValid(value);
  }
  static constexpr MessageType MessageType_MIN =
    IPGatewayICMPControl_MessageType_MessageType_MIN;
  static constexpr MessageType MessageType_MAX =
    IPGatewayICMPControl_MessageType_MessageType_MAX;
  static constexpr int MessageType_ARRAYSIZE =
    IPGatewayICMPControl_MessageType_MessageType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MessageType_descriptor() {
    return IPGatewayICMPControl_MessageType_descriptor();
  }
  template<typename T>
  static inline const std::string& MessageType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MessageType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MessageType_Name.");
    return IPGatewayICMPControl_MessageType_Name(enum_t_value);
  }
  static inline bool MessageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MessageType* value) {
    return IPGatewayICMPControl_MessageType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kAddressFieldNumber = 2,
    kQueueReportFieldNumber = 3,
    kTypeFieldNumber = 1,
  };
  // required string address = 2;
  bool has_address() const;
  private:
  bool _internal_has_address() const;
  public:
  void clear_address();
  const std::string& address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_address();
  PROTOBUF_NODISCARD std::string* release_address();
  void set_allocated_address(std::string* address);
  private:
  const std::string& _internal_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value);
  std::string* _internal_mutable_address();
  public:
 
  // optional .goby.acomms.protobuf.IPGatewayICMPControl.QueueReport queue_report = 3;
  bool has_queue_report() const;
  private:
  bool _internal_has_queue_report() const;
  public:
  void clear_queue_report();
  const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport& queue_report() const;
  PROTOBUF_NODISCARD ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* release_queue_report();
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* mutable_queue_report();
  void set_allocated_queue_report(::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* queue_report);
  private:
  const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport& _internal_queue_report() const;
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* _internal_mutable_queue_report();
  public:
  void unsafe_arena_set_allocated_queue_report(
      ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* queue_report);
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* unsafe_arena_release_queue_report();
 
  // required .goby.acomms.protobuf.IPGatewayICMPControl.MessageType type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType type() const;
  void set_type(::goby::acomms::protobuf::IPGatewayICMPControl_MessageType value);
  private:
  ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType _internal_type() const;
  void _internal_set_type(::goby::acomms::protobuf::IPGatewayICMPControl_MessageType value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.acomms.protobuf.IPGatewayICMPControl)
 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 address_;
    ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* queue_report_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2facomms_2fprotobuf_2fnetwork_5fheader_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// NetworkHeader_UDPHeader
 
// repeated uint32 srcdest_port = 1 [(.dccl.field) = {
inline int NetworkHeader_UDPHeader::_internal_srcdest_port_size() const {
  return _impl_.srcdest_port_.size();
}
inline int NetworkHeader_UDPHeader::srcdest_port_size() const {
  return _internal_srcdest_port_size();
}
inline void NetworkHeader_UDPHeader::clear_srcdest_port() {
  _impl_.srcdest_port_.Clear();
}
inline uint32_t NetworkHeader_UDPHeader::_internal_srcdest_port(int index) const {
  return _impl_.srcdest_port_.Get(index);
}
inline uint32_t NetworkHeader_UDPHeader::srcdest_port(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.NetworkHeader.UDPHeader.srcdest_port)
  return _internal_srcdest_port(index);
}
inline void NetworkHeader_UDPHeader::set_srcdest_port(int index, uint32_t value) {
  _impl_.srcdest_port_.Set(index, value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.NetworkHeader.UDPHeader.srcdest_port)
}
inline void NetworkHeader_UDPHeader::_internal_add_srcdest_port(uint32_t value) {
  _impl_.srcdest_port_.Add(value);
}
inline void NetworkHeader_UDPHeader::add_srcdest_port(uint32_t value) {
  _internal_add_srcdest_port(value);
  // @@protoc_insertion_point(field_add:goby.acomms.protobuf.NetworkHeader.UDPHeader.srcdest_port)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
NetworkHeader_UDPHeader::_internal_srcdest_port() const {
  return _impl_.srcdest_port_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
NetworkHeader_UDPHeader::srcdest_port() const {
  // @@protoc_insertion_point(field_list:goby.acomms.protobuf.NetworkHeader.UDPHeader.srcdest_port)
  return _internal_srcdest_port();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
NetworkHeader_UDPHeader::_internal_mutable_srcdest_port() {
  return &_impl_.srcdest_port_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
NetworkHeader_UDPHeader::mutable_srcdest_port() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.protobuf.NetworkHeader.UDPHeader.srcdest_port)
  return _internal_mutable_srcdest_port();
}
 
// -------------------------------------------------------------------
 
// NetworkHeader_ICMPHeader
 
// -------------------------------------------------------------------
 
// NetworkHeader_SCTPHeader
 
// -------------------------------------------------------------------
 
// NetworkHeader
 
// required .goby.acomms.protobuf.NetworkHeader.Protocol protocol = 1;
inline bool NetworkHeader::_internal_has_protocol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NetworkHeader::has_protocol() const {
  return _internal_has_protocol();
}
inline void NetworkHeader::clear_protocol() {
  _impl_.protocol_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::acomms::protobuf::NetworkHeader_Protocol NetworkHeader::_internal_protocol() const {
  return static_cast< ::goby::acomms::protobuf::NetworkHeader_Protocol >(_impl_.protocol_);
}
inline ::goby::acomms::protobuf::NetworkHeader_Protocol NetworkHeader::protocol() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.NetworkHeader.protocol)
  return _internal_protocol();
}
inline void NetworkHeader::_internal_set_protocol(::goby::acomms::protobuf::NetworkHeader_Protocol value) {
  assert(::goby::acomms::protobuf::NetworkHeader_Protocol_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.protocol_ = value;
}
inline void NetworkHeader::set_protocol(::goby::acomms::protobuf::NetworkHeader_Protocol value) {
  _internal_set_protocol(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.NetworkHeader.protocol)
}
 
// required uint32 srcdest_addr = 10 [(.dccl.field) = {
inline bool NetworkHeader::_internal_has_srcdest_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NetworkHeader::has_srcdest_addr() const {
  return _internal_has_srcdest_addr();
}
inline void NetworkHeader::clear_srcdest_addr() {
  _impl_.srcdest_addr_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t NetworkHeader::_internal_srcdest_addr() const {
  return _impl_.srcdest_addr_;
}
inline uint32_t NetworkHeader::srcdest_addr() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.NetworkHeader.srcdest_addr)
  return _internal_srcdest_addr();
}
inline void NetworkHeader::_internal_set_srcdest_addr(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.srcdest_addr_ = value;
}
inline void NetworkHeader::set_srcdest_addr(uint32_t value) {
  _internal_set_srcdest_addr(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.NetworkHeader.srcdest_addr)
}
 
// required .goby.acomms.protobuf.NetworkHeader.UDPHeader udp = 20;
inline bool NetworkHeader::_internal_has_udp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.udp_ != nullptr);
  return value;
}
inline bool NetworkHeader::has_udp() const {
  return _internal_has_udp();
}
inline void NetworkHeader::clear_udp() {
  if (_impl_.udp_ != nullptr) _impl_.udp_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::acomms::protobuf::NetworkHeader_UDPHeader& NetworkHeader::_internal_udp() const {
  const ::goby::acomms::protobuf::NetworkHeader_UDPHeader* p = _impl_.udp_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::NetworkHeader_UDPHeader&>(
      ::goby::acomms::protobuf::_NetworkHeader_UDPHeader_default_instance_);
}
inline const ::goby::acomms::protobuf::NetworkHeader_UDPHeader& NetworkHeader::udp() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.NetworkHeader.udp)
  return _internal_udp();
}
inline void NetworkHeader::unsafe_arena_set_allocated_udp(
    ::goby::acomms::protobuf::NetworkHeader_UDPHeader* udp) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.udp_);
  }
  _impl_.udp_ = udp;
  if (udp) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.protobuf.NetworkHeader.udp)
}
inline ::goby::acomms::protobuf::NetworkHeader_UDPHeader* NetworkHeader::release_udp() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* temp = _impl_.udp_;
  _impl_.udp_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::protobuf::NetworkHeader_UDPHeader* NetworkHeader::unsafe_arena_release_udp() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.NetworkHeader.udp)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* temp = _impl_.udp_;
  _impl_.udp_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::NetworkHeader_UDPHeader* NetworkHeader::_internal_mutable_udp() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.udp_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::NetworkHeader_UDPHeader>(GetArenaForAllocation());
    _impl_.udp_ = p;
  }
  return _impl_.udp_;
}
inline ::goby::acomms::protobuf::NetworkHeader_UDPHeader* NetworkHeader::mutable_udp() {
  ::goby::acomms::protobuf::NetworkHeader_UDPHeader* _msg = _internal_mutable_udp();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.NetworkHeader.udp)
  return _msg;
}
inline void NetworkHeader::set_allocated_udp(::goby::acomms::protobuf::NetworkHeader_UDPHeader* udp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.udp_;
  }
  if (udp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(udp);
    if (message_arena != submessage_arena) {
      udp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, udp, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.udp_ = udp;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.NetworkHeader.udp)
}
 
// -------------------------------------------------------------------
 
// IPv4Header_FlagsFragOffset
 
// required bool dont_fragment = 1;
inline bool IPv4Header_FlagsFragOffset::_internal_has_dont_fragment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IPv4Header_FlagsFragOffset::has_dont_fragment() const {
  return _internal_has_dont_fragment();
}
inline void IPv4Header_FlagsFragOffset::clear_dont_fragment() {
  _impl_.dont_fragment_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool IPv4Header_FlagsFragOffset::_internal_dont_fragment() const {
  return _impl_.dont_fragment_;
}
inline bool IPv4Header_FlagsFragOffset::dont_fragment() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.dont_fragment)
  return _internal_dont_fragment();
}
inline void IPv4Header_FlagsFragOffset::_internal_set_dont_fragment(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dont_fragment_ = value;
}
inline void IPv4Header_FlagsFragOffset::set_dont_fragment(bool value) {
  _internal_set_dont_fragment(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.dont_fragment)
}
 
// required bool more_fragments = 2;
inline bool IPv4Header_FlagsFragOffset::_internal_has_more_fragments() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IPv4Header_FlagsFragOffset::has_more_fragments() const {
  return _internal_has_more_fragments();
}
inline void IPv4Header_FlagsFragOffset::clear_more_fragments() {
  _impl_.more_fragments_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool IPv4Header_FlagsFragOffset::_internal_more_fragments() const {
  return _impl_.more_fragments_;
}
inline bool IPv4Header_FlagsFragOffset::more_fragments() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.more_fragments)
  return _internal_more_fragments();
}
inline void IPv4Header_FlagsFragOffset::_internal_set_more_fragments(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.more_fragments_ = value;
}
inline void IPv4Header_FlagsFragOffset::set_more_fragments(bool value) {
  _internal_set_more_fragments(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.more_fragments)
}
 
// required uint32 fragment_offset = 3;
inline bool IPv4Header_FlagsFragOffset::_internal_has_fragment_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool IPv4Header_FlagsFragOffset::has_fragment_offset() const {
  return _internal_has_fragment_offset();
}
inline void IPv4Header_FlagsFragOffset::clear_fragment_offset() {
  _impl_.fragment_offset_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t IPv4Header_FlagsFragOffset::_internal_fragment_offset() const {
  return _impl_.fragment_offset_;
}
inline uint32_t IPv4Header_FlagsFragOffset::fragment_offset() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.fragment_offset)
  return _internal_fragment_offset();
}
inline void IPv4Header_FlagsFragOffset::_internal_set_fragment_offset(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fragment_offset_ = value;
}
inline void IPv4Header_FlagsFragOffset::set_fragment_offset(uint32_t value) {
  _internal_set_fragment_offset(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.FlagsFragOffset.fragment_offset)
}
 
// -------------------------------------------------------------------
 
// IPv4Header
 
// required uint32 ihl = 2 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_ihl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool IPv4Header::has_ihl() const {
  return _internal_has_ihl();
}
inline void IPv4Header::clear_ihl() {
  _impl_.ihl_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t IPv4Header::_internal_ihl() const {
  return _impl_.ihl_;
}
inline uint32_t IPv4Header::ihl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.ihl)
  return _internal_ihl();
}
inline void IPv4Header::_internal_set_ihl(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.ihl_ = value;
}
inline void IPv4Header::set_ihl(uint32_t value) {
  _internal_set_ihl(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.ihl)
}
 
// required uint32 version = 1 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool IPv4Header::has_version() const {
  return _internal_has_version();
}
inline void IPv4Header::clear_version() {
  _impl_.version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t IPv4Header::_internal_version() const {
  return _impl_.version_;
}
inline uint32_t IPv4Header::version() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.version)
  return _internal_version();
}
inline void IPv4Header::_internal_set_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.version_ = value;
}
inline void IPv4Header::set_version(uint32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.version)
}
 
// required uint32 ecn = 4 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_ecn() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool IPv4Header::has_ecn() const {
  return _internal_has_ecn();
}
inline void IPv4Header::clear_ecn() {
  _impl_.ecn_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t IPv4Header::_internal_ecn() const {
  return _impl_.ecn_;
}
inline uint32_t IPv4Header::ecn() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.ecn)
  return _internal_ecn();
}
inline void IPv4Header::_internal_set_ecn(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.ecn_ = value;
}
inline void IPv4Header::set_ecn(uint32_t value) {
  _internal_set_ecn(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.ecn)
}
 
// required uint32 dscp = 3 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_dscp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool IPv4Header::has_dscp() const {
  return _internal_has_dscp();
}
inline void IPv4Header::clear_dscp() {
  _impl_.dscp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t IPv4Header::_internal_dscp() const {
  return _impl_.dscp_;
}
inline uint32_t IPv4Header::dscp() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.dscp)
  return _internal_dscp();
}
inline void IPv4Header::_internal_set_dscp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.dscp_ = value;
}
inline void IPv4Header::set_dscp(uint32_t value) {
  _internal_set_dscp(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.dscp)
}
 
// required uint32 total_length = 5 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_total_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool IPv4Header::has_total_length() const {
  return _internal_has_total_length();
}
inline void IPv4Header::clear_total_length() {
  _impl_.total_length_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t IPv4Header::_internal_total_length() const {
  return _impl_.total_length_;
}
inline uint32_t IPv4Header::total_length() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.total_length)
  return _internal_total_length();
}
inline void IPv4Header::_internal_set_total_length(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.total_length_ = value;
}
inline void IPv4Header::set_total_length(uint32_t value) {
  _internal_set_total_length(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.total_length)
}
 
// required uint32 identification = 6 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_identification() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool IPv4Header::has_identification() const {
  return _internal_has_identification();
}
inline void IPv4Header::clear_identification() {
  _impl_.identification_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t IPv4Header::_internal_identification() const {
  return _impl_.identification_;
}
inline uint32_t IPv4Header::identification() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.identification)
  return _internal_identification();
}
inline void IPv4Header::_internal_set_identification(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.identification_ = value;
}
inline void IPv4Header::set_identification(uint32_t value) {
  _internal_set_identification(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.identification)
}
 
// required .goby.acomms.protobuf.IPv4Header.FlagsFragOffset flags_frag_offset = 7 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_flags_frag_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.flags_frag_offset_ != nullptr);
  return value;
}
inline bool IPv4Header::has_flags_frag_offset() const {
  return _internal_has_flags_frag_offset();
}
inline void IPv4Header::clear_flags_frag_offset() {
  if (_impl_.flags_frag_offset_ != nullptr) _impl_.flags_frag_offset_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset& IPv4Header::_internal_flags_frag_offset() const {
  const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* p = _impl_.flags_frag_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset&>(
      ::goby::acomms::protobuf::_IPv4Header_FlagsFragOffset_default_instance_);
}
inline const ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset& IPv4Header::flags_frag_offset() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.flags_frag_offset)
  return _internal_flags_frag_offset();
}
inline void IPv4Header::unsafe_arena_set_allocated_flags_frag_offset(
    ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* flags_frag_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.flags_frag_offset_);
  }
  _impl_.flags_frag_offset_ = flags_frag_offset;
  if (flags_frag_offset) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.protobuf.IPv4Header.flags_frag_offset)
}
inline ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* IPv4Header::release_flags_frag_offset() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* temp = _impl_.flags_frag_offset_;
  _impl_.flags_frag_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* IPv4Header::unsafe_arena_release_flags_frag_offset() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.IPv4Header.flags_frag_offset)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* temp = _impl_.flags_frag_offset_;
  _impl_.flags_frag_offset_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* IPv4Header::_internal_mutable_flags_frag_offset() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.flags_frag_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::IPv4Header_FlagsFragOffset>(GetArenaForAllocation());
    _impl_.flags_frag_offset_ = p;
  }
  return _impl_.flags_frag_offset_;
}
inline ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* IPv4Header::mutable_flags_frag_offset() {
  ::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* _msg = _internal_mutable_flags_frag_offset();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPv4Header.flags_frag_offset)
  return _msg;
}
inline void IPv4Header::set_allocated_flags_frag_offset(::goby::acomms::protobuf::IPv4Header_FlagsFragOffset* flags_frag_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.flags_frag_offset_;
  }
  if (flags_frag_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(flags_frag_offset);
    if (message_arena != submessage_arena) {
      flags_frag_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, flags_frag_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.flags_frag_offset_ = flags_frag_offset;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.IPv4Header.flags_frag_offset)
}
 
// required uint32 ttl = 8 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_ttl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool IPv4Header::has_ttl() const {
  return _internal_has_ttl();
}
inline void IPv4Header::clear_ttl() {
  _impl_.ttl_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t IPv4Header::_internal_ttl() const {
  return _impl_.ttl_;
}
inline uint32_t IPv4Header::ttl() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.ttl)
  return _internal_ttl();
}
inline void IPv4Header::_internal_set_ttl(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.ttl_ = value;
}
inline void IPv4Header::set_ttl(uint32_t value) {
  _internal_set_ttl(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.ttl)
}
 
// required uint32 protocol = 9 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_protocol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool IPv4Header::has_protocol() const {
  return _internal_has_protocol();
}
inline void IPv4Header::clear_protocol() {
  _impl_.protocol_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t IPv4Header::_internal_protocol() const {
  return _impl_.protocol_;
}
inline uint32_t IPv4Header::protocol() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.protocol)
  return _internal_protocol();
}
inline void IPv4Header::_internal_set_protocol(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.protocol_ = value;
}
inline void IPv4Header::set_protocol(uint32_t value) {
  _internal_set_protocol(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.protocol)
}
 
// required uint32 header_checksum = 10 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_header_checksum() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool IPv4Header::has_header_checksum() const {
  return _internal_has_header_checksum();
}
inline void IPv4Header::clear_header_checksum() {
  _impl_.header_checksum_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t IPv4Header::_internal_header_checksum() const {
  return _impl_.header_checksum_;
}
inline uint32_t IPv4Header::header_checksum() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.header_checksum)
  return _internal_header_checksum();
}
inline void IPv4Header::_internal_set_header_checksum(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.header_checksum_ = value;
}
inline void IPv4Header::set_header_checksum(uint32_t value) {
  _internal_set_header_checksum(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.header_checksum)
}
 
// required string source_ip_address = 11 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_source_ip_address() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IPv4Header::has_source_ip_address() const {
  return _internal_has_source_ip_address();
}
inline void IPv4Header::clear_source_ip_address() {
  _impl_.source_ip_address_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IPv4Header::source_ip_address() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.source_ip_address)
  return _internal_source_ip_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IPv4Header::set_source_ip_address(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.source_ip_address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.source_ip_address)
}
inline std::string* IPv4Header::mutable_source_ip_address() {
  std::string* _s = _internal_mutable_source_ip_address();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPv4Header.source_ip_address)
  return _s;
}
inline const std::string& IPv4Header::_internal_source_ip_address() const {
  return _impl_.source_ip_address_.Get();
}
inline void IPv4Header::_internal_set_source_ip_address(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_ip_address_.Set(value, GetArenaForAllocation());
}
inline std::string* IPv4Header::_internal_mutable_source_ip_address() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.source_ip_address_.Mutable(GetArenaForAllocation());
}
inline std::string* IPv4Header::release_source_ip_address() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.IPv4Header.source_ip_address)
  if (!_internal_has_source_ip_address()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.source_ip_address_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_ip_address_.IsDefault()) {
    _impl_.source_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IPv4Header::set_allocated_source_ip_address(std::string* source_ip_address) {
  if (source_ip_address != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.source_ip_address_.SetAllocated(source_ip_address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_ip_address_.IsDefault()) {
    _impl_.source_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.IPv4Header.source_ip_address)
}
 
// required string dest_ip_address = 12 [(.dccl.field) = {
inline bool IPv4Header::_internal_has_dest_ip_address() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IPv4Header::has_dest_ip_address() const {
  return _internal_has_dest_ip_address();
}
inline void IPv4Header::clear_dest_ip_address() {
  _impl_.dest_ip_address_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& IPv4Header::dest_ip_address() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPv4Header.dest_ip_address)
  return _internal_dest_ip_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IPv4Header::set_dest_ip_address(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.dest_ip_address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPv4Header.dest_ip_address)
}
inline std::string* IPv4Header::mutable_dest_ip_address() {
  std::string* _s = _internal_mutable_dest_ip_address();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPv4Header.dest_ip_address)
  return _s;
}
inline const std::string& IPv4Header::_internal_dest_ip_address() const {
  return _impl_.dest_ip_address_.Get();
}
inline void IPv4Header::_internal_set_dest_ip_address(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dest_ip_address_.Set(value, GetArenaForAllocation());
}
inline std::string* IPv4Header::_internal_mutable_dest_ip_address() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.dest_ip_address_.Mutable(GetArenaForAllocation());
}
inline std::string* IPv4Header::release_dest_ip_address() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.IPv4Header.dest_ip_address)
  if (!_internal_has_dest_ip_address()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.dest_ip_address_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dest_ip_address_.IsDefault()) {
    _impl_.dest_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IPv4Header::set_allocated_dest_ip_address(std::string* dest_ip_address) {
  if (dest_ip_address != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.dest_ip_address_.SetAllocated(dest_ip_address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dest_ip_address_.IsDefault()) {
    _impl_.dest_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.IPv4Header.dest_ip_address)
}
 
// -------------------------------------------------------------------
 
// UDPHeader
 
// required uint32 source_port = 1 [(.dccl.field) = {
inline bool UDPHeader::_internal_has_source_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UDPHeader::has_source_port() const {
  return _internal_has_source_port();
}
inline void UDPHeader::clear_source_port() {
  _impl_.source_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t UDPHeader::_internal_source_port() const {
  return _impl_.source_port_;
}
inline uint32_t UDPHeader::source_port() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.UDPHeader.source_port)
  return _internal_source_port();
}
inline void UDPHeader::_internal_set_source_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.source_port_ = value;
}
inline void UDPHeader::set_source_port(uint32_t value) {
  _internal_set_source_port(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.UDPHeader.source_port)
}
 
// required uint32 dest_port = 2 [(.dccl.field) = {
inline bool UDPHeader::_internal_has_dest_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UDPHeader::has_dest_port() const {
  return _internal_has_dest_port();
}
inline void UDPHeader::clear_dest_port() {
  _impl_.dest_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t UDPHeader::_internal_dest_port() const {
  return _impl_.dest_port_;
}
inline uint32_t UDPHeader::dest_port() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.UDPHeader.dest_port)
  return _internal_dest_port();
}
inline void UDPHeader::_internal_set_dest_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dest_port_ = value;
}
inline void UDPHeader::set_dest_port(uint32_t value) {
  _internal_set_dest_port(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.UDPHeader.dest_port)
}
 
// required uint32 length = 3 [(.dccl.field) = {
inline bool UDPHeader::_internal_has_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool UDPHeader::has_length() const {
  return _internal_has_length();
}
inline void UDPHeader::clear_length() {
  _impl_.length_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t UDPHeader::_internal_length() const {
  return _impl_.length_;
}
inline uint32_t UDPHeader::length() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.UDPHeader.length)
  return _internal_length();
}
inline void UDPHeader::_internal_set_length(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.length_ = value;
}
inline void UDPHeader::set_length(uint32_t value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.UDPHeader.length)
}
 
// required uint32 checksum = 4 [(.dccl.field) = {
inline bool UDPHeader::_internal_has_checksum() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool UDPHeader::has_checksum() const {
  return _internal_has_checksum();
}
inline void UDPHeader::clear_checksum() {
  _impl_.checksum_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t UDPHeader::_internal_checksum() const {
  return _impl_.checksum_;
}
inline uint32_t UDPHeader::checksum() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.UDPHeader.checksum)
  return _internal_checksum();
}
inline void UDPHeader::_internal_set_checksum(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.checksum_ = value;
}
inline void UDPHeader::set_checksum(uint32_t value) {
  _internal_set_checksum(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.UDPHeader.checksum)
}
 
// -------------------------------------------------------------------
 
// ICMPHeader
 
// required uint32 type = 1 [(.dccl.field) = {
inline bool ICMPHeader::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ICMPHeader::has_type() const {
  return _internal_has_type();
}
inline void ICMPHeader::clear_type() {
  _impl_.type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ICMPHeader::_internal_type() const {
  return _impl_.type_;
}
inline uint32_t ICMPHeader::type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.ICMPHeader.type)
  return _internal_type();
}
inline void ICMPHeader::_internal_set_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void ICMPHeader::set_type(uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.ICMPHeader.type)
}
 
// required uint32 code = 2 [(.dccl.field) = {
inline bool ICMPHeader::_internal_has_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ICMPHeader::has_code() const {
  return _internal_has_code();
}
inline void ICMPHeader::clear_code() {
  _impl_.code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ICMPHeader::_internal_code() const {
  return _impl_.code_;
}
inline uint32_t ICMPHeader::code() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.ICMPHeader.code)
  return _internal_code();
}
inline void ICMPHeader::_internal_set_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.code_ = value;
}
inline void ICMPHeader::set_code(uint32_t value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.ICMPHeader.code)
}
 
// required uint32 checksum = 3 [(.dccl.field) = {
inline bool ICMPHeader::_internal_has_checksum() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ICMPHeader::has_checksum() const {
  return _internal_has_checksum();
}
inline void ICMPHeader::clear_checksum() {
  _impl_.checksum_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ICMPHeader::_internal_checksum() const {
  return _impl_.checksum_;
}
inline uint32_t ICMPHeader::checksum() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.ICMPHeader.checksum)
  return _internal_checksum();
}
inline void ICMPHeader::_internal_set_checksum(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.checksum_ = value;
}
inline void ICMPHeader::set_checksum(uint32_t value) {
  _internal_set_checksum(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.ICMPHeader.checksum)
}
 
// required uint32 short1 = 4 [(.dccl.field) = {
inline bool ICMPHeader::_internal_has_short1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ICMPHeader::has_short1() const {
  return _internal_has_short1();
}
inline void ICMPHeader::clear_short1() {
  _impl_.short1_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ICMPHeader::_internal_short1() const {
  return _impl_.short1_;
}
inline uint32_t ICMPHeader::short1() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.ICMPHeader.short1)
  return _internal_short1();
}
inline void ICMPHeader::_internal_set_short1(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.short1_ = value;
}
inline void ICMPHeader::set_short1(uint32_t value) {
  _internal_set_short1(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.ICMPHeader.short1)
}
 
// required uint32 short2 = 5 [(.dccl.field) = {
inline bool ICMPHeader::_internal_has_short2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ICMPHeader::has_short2() const {
  return _internal_has_short2();
}
inline void ICMPHeader::clear_short2() {
  _impl_.short2_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ICMPHeader::_internal_short2() const {
  return _impl_.short2_;
}
inline uint32_t ICMPHeader::short2() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.ICMPHeader.short2)
  return _internal_short2();
}
inline void ICMPHeader::_internal_set_short2(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.short2_ = value;
}
inline void ICMPHeader::set_short2(uint32_t value) {
  _internal_set_short2(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.ICMPHeader.short2)
}
 
// -------------------------------------------------------------------
 
// IPGatewayICMPControl_QueueReport_SubQueue
 
// required int32 dest = 1;
inline bool IPGatewayICMPControl_QueueReport_SubQueue::_internal_has_dest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IPGatewayICMPControl_QueueReport_SubQueue::has_dest() const {
  return _internal_has_dest();
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::clear_dest() {
  _impl_.dest_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t IPGatewayICMPControl_QueueReport_SubQueue::_internal_dest() const {
  return _impl_.dest_;
}
inline int32_t IPGatewayICMPControl_QueueReport_SubQueue::dest() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue.dest)
  return _internal_dest();
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::_internal_set_dest(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dest_ = value;
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::set_dest(int32_t value) {
  _internal_set_dest(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue.dest)
}
 
// required int32 size = 2;
inline bool IPGatewayICMPControl_QueueReport_SubQueue::_internal_has_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IPGatewayICMPControl_QueueReport_SubQueue::has_size() const {
  return _internal_has_size();
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::clear_size() {
  _impl_.size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t IPGatewayICMPControl_QueueReport_SubQueue::_internal_size() const {
  return _impl_.size_;
}
inline int32_t IPGatewayICMPControl_QueueReport_SubQueue::size() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue.size)
  return _internal_size();
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::_internal_set_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.size_ = value;
}
inline void IPGatewayICMPControl_QueueReport_SubQueue::set_size(int32_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue.size)
}
 
// -------------------------------------------------------------------
 
// IPGatewayICMPControl_QueueReport
 
// repeated .goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.SubQueue queue = 1;
inline int IPGatewayICMPControl_QueueReport::_internal_queue_size() const {
  return _impl_.queue_.size();
}
inline int IPGatewayICMPControl_QueueReport::queue_size() const {
  return _internal_queue_size();
}
inline void IPGatewayICMPControl_QueueReport::clear_queue() {
  _impl_.queue_.Clear();
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* IPGatewayICMPControl_QueueReport::mutable_queue(int index) {
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.queue)
  return _impl_.queue_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue >*
IPGatewayICMPControl_QueueReport::mutable_queue() {
  // @@protoc_insertion_point(field_mutable_list:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.queue)
  return &_impl_.queue_;
}
inline const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue& IPGatewayICMPControl_QueueReport::_internal_queue(int index) const {
  return _impl_.queue_.Get(index);
}
inline const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue& IPGatewayICMPControl_QueueReport::queue(int index) const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.queue)
  return _internal_queue(index);
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* IPGatewayICMPControl_QueueReport::_internal_add_queue() {
  return _impl_.queue_.Add();
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* IPGatewayICMPControl_QueueReport::add_queue() {
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue* _add = _internal_add_queue();
  // @@protoc_insertion_point(field_add:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.queue)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport_SubQueue >&
IPGatewayICMPControl_QueueReport::queue() const {
  // @@protoc_insertion_point(field_list:goby.acomms.protobuf.IPGatewayICMPControl.QueueReport.queue)
  return _impl_.queue_;
}
 
// -------------------------------------------------------------------
 
// IPGatewayICMPControl
 
// required .goby.acomms.protobuf.IPGatewayICMPControl.MessageType type = 1;
inline bool IPGatewayICMPControl::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool IPGatewayICMPControl::has_type() const {
  return _internal_has_type();
}
inline void IPGatewayICMPControl::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType IPGatewayICMPControl::_internal_type() const {
  return static_cast< ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType >(_impl_.type_);
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType IPGatewayICMPControl::type() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.type)
  return _internal_type();
}
inline void IPGatewayICMPControl::_internal_set_type(::goby::acomms::protobuf::IPGatewayICMPControl_MessageType value) {
  assert(::goby::acomms::protobuf::IPGatewayICMPControl_MessageType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void IPGatewayICMPControl::set_type(::goby::acomms::protobuf::IPGatewayICMPControl_MessageType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPGatewayICMPControl.type)
}
 
// required string address = 2;
inline bool IPGatewayICMPControl::_internal_has_address() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IPGatewayICMPControl::has_address() const {
  return _internal_has_address();
}
inline void IPGatewayICMPControl::clear_address() {
  _impl_.address_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IPGatewayICMPControl::address() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.address)
  return _internal_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IPGatewayICMPControl::set_address(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.acomms.protobuf.IPGatewayICMPControl.address)
}
inline std::string* IPGatewayICMPControl::mutable_address() {
  std::string* _s = _internal_mutable_address();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPGatewayICMPControl.address)
  return _s;
}
inline const std::string& IPGatewayICMPControl::_internal_address() const {
  return _impl_.address_.Get();
}
inline void IPGatewayICMPControl::_internal_set_address(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.address_.Set(value, GetArenaForAllocation());
}
inline std::string* IPGatewayICMPControl::_internal_mutable_address() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.address_.Mutable(GetArenaForAllocation());
}
inline std::string* IPGatewayICMPControl::release_address() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.IPGatewayICMPControl.address)
  if (!_internal_has_address()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.address_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IPGatewayICMPControl::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.address_.SetAllocated(address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.IPGatewayICMPControl.address)
}
 
// optional .goby.acomms.protobuf.IPGatewayICMPControl.QueueReport queue_report = 3;
inline bool IPGatewayICMPControl::_internal_has_queue_report() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.queue_report_ != nullptr);
  return value;
}
inline bool IPGatewayICMPControl::has_queue_report() const {
  return _internal_has_queue_report();
}
inline void IPGatewayICMPControl::clear_queue_report() {
  if (_impl_.queue_report_ != nullptr) _impl_.queue_report_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport& IPGatewayICMPControl::_internal_queue_report() const {
  const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* p = _impl_.queue_report_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport&>(
      ::goby::acomms::protobuf::_IPGatewayICMPControl_QueueReport_default_instance_);
}
inline const ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport& IPGatewayICMPControl::queue_report() const {
  // @@protoc_insertion_point(field_get:goby.acomms.protobuf.IPGatewayICMPControl.queue_report)
  return _internal_queue_report();
}
inline void IPGatewayICMPControl::unsafe_arena_set_allocated_queue_report(
    ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* queue_report) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.queue_report_);
  }
  _impl_.queue_report_ = queue_report;
  if (queue_report) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.acomms.protobuf.IPGatewayICMPControl.queue_report)
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* IPGatewayICMPControl::release_queue_report() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* temp = _impl_.queue_report_;
  _impl_.queue_report_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* IPGatewayICMPControl::unsafe_arena_release_queue_report() {
  // @@protoc_insertion_point(field_release:goby.acomms.protobuf.IPGatewayICMPControl.queue_report)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* temp = _impl_.queue_report_;
  _impl_.queue_report_ = nullptr;
  return temp;
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* IPGatewayICMPControl::_internal_mutable_queue_report() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.queue_report_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport>(GetArenaForAllocation());
    _impl_.queue_report_ = p;
  }
  return _impl_.queue_report_;
}
inline ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* IPGatewayICMPControl::mutable_queue_report() {
  ::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* _msg = _internal_mutable_queue_report();
  // @@protoc_insertion_point(field_mutable:goby.acomms.protobuf.IPGatewayICMPControl.queue_report)
  return _msg;
}
inline void IPGatewayICMPControl::set_allocated_queue_report(::goby::acomms::protobuf::IPGatewayICMPControl_QueueReport* queue_report) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.queue_report_;
  }
  if (queue_report) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(queue_report);
    if (message_arena != submessage_arena) {
      queue_report = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, queue_report, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.queue_report_ = queue_report;
  // @@protoc_insertion_point(field_set_allocated:goby.acomms.protobuf.IPGatewayICMPControl.queue_report)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace acomms
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::acomms::protobuf::NetworkHeader_Protocol> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::protobuf::NetworkHeader_Protocol>() {
  return ::goby::acomms::protobuf::NetworkHeader_Protocol_descriptor();
}
template <> struct is_proto_enum< ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType>() {
  return ::goby::acomms::protobuf::IPGatewayICMPControl_MessageType_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_2fnetwork_5fheader_2eproto