iBellhop_messages.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: netsim/acousticstoolbox/iBellhop_messages.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "goby/moos/protobuf/goby_moos_app.pb.h"
#include "goby/protobuf/option_extensions.pb.h"
#include "netsim/acousticstoolbox/environment.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_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
namespace netsim {
namespace protobuf {
class SVPInfoRequest;
struct SVPInfoRequestDefaultTypeInternal;
extern SVPInfoRequestDefaultTypeInternal _SVPInfoRequest_default_instance_;
class SVPInfoResponse;
struct SVPInfoResponseDefaultTypeInternal;
extern SVPInfoResponseDefaultTypeInternal _SVPInfoResponse_default_instance_;
class SVPInfoResponse_SVPSample;
struct SVPInfoResponse_SVPSampleDefaultTypeInternal;
extern SVPInfoResponse_SVPSampleDefaultTypeInternal _SVPInfoResponse_SVPSample_default_instance_;
class iBellhopConfig;
struct iBellhopConfigDefaultTypeInternal;
extern iBellhopConfigDefaultTypeInternal _iBellhopConfig_default_instance_;
class iBellhopRequest;
struct iBellhopRequestDefaultTypeInternal;
extern iBellhopRequestDefaultTypeInternal _iBellhopRequest_default_instance_;
class iBellhopResponse;
struct iBellhopResponseDefaultTypeInternal;
extern iBellhopResponseDefaultTypeInternal _iBellhopResponse_default_instance_;
class iBellhopResponse_TLAveragedInRange;
struct iBellhopResponse_TLAveragedInRangeDefaultTypeInternal;
extern iBellhopResponse_TLAveragedInRangeDefaultTypeInternal _iBellhopResponse_TLAveragedInRange_default_instance_;
class iBellhopResponse_TLAveragedInRange_TLSample;
struct iBellhopResponse_TLAveragedInRange_TLSampleDefaultTypeInternal;
extern iBellhopResponse_TLAveragedInRange_TLSampleDefaultTypeInternal _iBellhopResponse_TLAveragedInRange_TLSample_default_instance_;
}  // namespace protobuf
}  // namespace netsim
PROTOBUF_NAMESPACE_OPEN
template<> ::netsim::protobuf::SVPInfoRequest* Arena::CreateMaybeMessage<::netsim::protobuf::SVPInfoRequest>(Arena*);
template<> ::netsim::protobuf::SVPInfoResponse* Arena::CreateMaybeMessage<::netsim::protobuf::SVPInfoResponse>(Arena*);
template<> ::netsim::protobuf::SVPInfoResponse_SVPSample* Arena::CreateMaybeMessage<::netsim::protobuf::SVPInfoResponse_SVPSample>(Arena*);
template<> ::netsim::protobuf::iBellhopConfig* Arena::CreateMaybeMessage<::netsim::protobuf::iBellhopConfig>(Arena*);
template<> ::netsim::protobuf::iBellhopRequest* Arena::CreateMaybeMessage<::netsim::protobuf::iBellhopRequest>(Arena*);
template<> ::netsim::protobuf::iBellhopResponse* Arena::CreateMaybeMessage<::netsim::protobuf::iBellhopResponse>(Arena*);
template<> ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* Arena::CreateMaybeMessage<::netsim::protobuf::iBellhopResponse_TLAveragedInRange>(Arena*);
template<> ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* Arena::CreateMaybeMessage<::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace netsim {
namespace protobuf {
 
enum iBellhopRequest_WaterColumnAction : int {
  iBellhopRequest_WaterColumnAction_MERGE_WATER_COLUMNS = 1,
  iBellhopRequest_WaterColumnAction_MERGE_SAMPLES = 2,
  iBellhopRequest_WaterColumnAction_OVERWRITE = 3
};
bool iBellhopRequest_WaterColumnAction_IsValid(int value);
constexpr iBellhopRequest_WaterColumnAction iBellhopRequest_WaterColumnAction_WaterColumnAction_MIN = iBellhopRequest_WaterColumnAction_MERGE_WATER_COLUMNS;
constexpr iBellhopRequest_WaterColumnAction iBellhopRequest_WaterColumnAction_WaterColumnAction_MAX = iBellhopRequest_WaterColumnAction_OVERWRITE;
constexpr int iBellhopRequest_WaterColumnAction_WaterColumnAction_ARRAYSIZE = iBellhopRequest_WaterColumnAction_WaterColumnAction_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* iBellhopRequest_WaterColumnAction_descriptor();
template<typename T>
inline const std::string& iBellhopRequest_WaterColumnAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, iBellhopRequest_WaterColumnAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function iBellhopRequest_WaterColumnAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    iBellhopRequest_WaterColumnAction_descriptor(), enum_t_value);
}
inline bool iBellhopRequest_WaterColumnAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, iBellhopRequest_WaterColumnAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<iBellhopRequest_WaterColumnAction>(
    iBellhopRequest_WaterColumnAction_descriptor(), name, value);
}
// ===================================================================
 
class iBellhopConfig final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.iBellhopConfig) */ {
 public:
  inline iBellhopConfig() : iBellhopConfig(nullptr) {}
  ~iBellhopConfig() override;
  explicit PROTOBUF_CONSTEXPR iBellhopConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  iBellhopConfig(const iBellhopConfig& from);
  iBellhopConfig(iBellhopConfig&& from) noexcept
    : iBellhopConfig() {
    *this = ::std::move(from);
  }
 
  inline iBellhopConfig& operator=(const iBellhopConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline iBellhopConfig& operator=(iBellhopConfig&& 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 iBellhopConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const iBellhopConfig* internal_default_instance() {
    return reinterpret_cast<const iBellhopConfig*>(
               &_iBellhopConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(iBellhopConfig& a, iBellhopConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(iBellhopConfig* 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(iBellhopConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  iBellhopConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iBellhopConfig>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iBellhopConfig& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iBellhopConfig& from) {
    iBellhopConfig::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(iBellhopConfig* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.iBellhopConfig";
  }
  protected:
  explicit iBellhopConfig(::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 {
    kMoosVarRequestFieldNumber = 3,
    kMoosVarResponseFieldNumber = 4,
    kOutputEnvDirFieldNumber = 5,
    kLocalSoundSpeedVarFieldNumber = 7,
    kCommonFieldNumber = 1,
    kInitialEnvFieldNumber = 2,
    kExtrapolateNavFieldNumber = 6,
    kMaxNumberOfReceiversFieldNumber = 10,
  };
  // optional string moos_var_request = 3 [default = "BELLHOP_REQUEST", (.goby.field) = {
  bool has_moos_var_request() const;
  private:
  bool _internal_has_moos_var_request() const;
  public:
  void clear_moos_var_request();
  const std::string& moos_var_request() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_moos_var_request(ArgT0&& arg0, ArgT... args);
  std::string* mutable_moos_var_request();
  PROTOBUF_NODISCARD std::string* release_moos_var_request();
  void set_allocated_moos_var_request(std::string* moos_var_request);
  private:
  const std::string& _internal_moos_var_request() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_moos_var_request(const std::string& value);
  std::string* _internal_mutable_moos_var_request();
  public:
 
  // optional string moos_var_response = 4 [default = "BELLHOP_RESPONSE", (.goby.field) = {
  bool has_moos_var_response() const;
  private:
  bool _internal_has_moos_var_response() const;
  public:
  void clear_moos_var_response();
  const std::string& moos_var_response() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_moos_var_response(ArgT0&& arg0, ArgT... args);
  std::string* mutable_moos_var_response();
  PROTOBUF_NODISCARD std::string* release_moos_var_response();
  void set_allocated_moos_var_response(std::string* moos_var_response);
  private:
  const std::string& _internal_moos_var_response() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_moos_var_response(const std::string& value);
  std::string* _internal_mutable_moos_var_response();
  public:
 
  // optional string output_env_dir = 5 [default = "/tmp", (.goby.field) = {
  bool has_output_env_dir() const;
  private:
  bool _internal_has_output_env_dir() const;
  public:
  void clear_output_env_dir();
  const std::string& output_env_dir() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_env_dir(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_env_dir();
  PROTOBUF_NODISCARD std::string* release_output_env_dir();
  void set_allocated_output_env_dir(std::string* output_env_dir);
  private:
  const std::string& _internal_output_env_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_env_dir(const std::string& value);
  std::string* _internal_mutable_output_env_dir();
  public:
 
  // optional string local_sound_speed_var = 7 [(.goby.field) = {
  bool has_local_sound_speed_var() const;
  private:
  bool _internal_has_local_sound_speed_var() const;
  public:
  void clear_local_sound_speed_var();
  const std::string& local_sound_speed_var() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_local_sound_speed_var(ArgT0&& arg0, ArgT... args);
  std::string* mutable_local_sound_speed_var();
  PROTOBUF_NODISCARD std::string* release_local_sound_speed_var();
  void set_allocated_local_sound_speed_var(std::string* local_sound_speed_var);
  private:
  const std::string& _internal_local_sound_speed_var() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_local_sound_speed_var(const std::string& value);
  std::string* _internal_mutable_local_sound_speed_var();
  public:
 
  // optional .goby.moos.protobuf.GobyMOOSAppConfig common = 1 [(.goby.field) = {
  bool has_common() const;
  private:
  bool _internal_has_common() const;
  public:
  void clear_common();
  const ::goby::moos::protobuf::GobyMOOSAppConfig& common() const;
  PROTOBUF_NODISCARD ::goby::moos::protobuf::GobyMOOSAppConfig* release_common();
  ::goby::moos::protobuf::GobyMOOSAppConfig* mutable_common();
  void set_allocated_common(::goby::moos::protobuf::GobyMOOSAppConfig* common);
  private:
  const ::goby::moos::protobuf::GobyMOOSAppConfig& _internal_common() const;
  ::goby::moos::protobuf::GobyMOOSAppConfig* _internal_mutable_common();
  public:
  void unsafe_arena_set_allocated_common(
      ::goby::moos::protobuf::GobyMOOSAppConfig* common);
  ::goby::moos::protobuf::GobyMOOSAppConfig* unsafe_arena_release_common();
 
  // required .netsim.bellhop.protobuf.Environment initial_env = 2 [(.goby.field) = {
  bool has_initial_env() const;
  private:
  bool _internal_has_initial_env() const;
  public:
  void clear_initial_env();
  const ::netsim::bellhop::protobuf::Environment& initial_env() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment* release_initial_env();
  ::netsim::bellhop::protobuf::Environment* mutable_initial_env();
  void set_allocated_initial_env(::netsim::bellhop::protobuf::Environment* initial_env);
  private:
  const ::netsim::bellhop::protobuf::Environment& _internal_initial_env() const;
  ::netsim::bellhop::protobuf::Environment* _internal_mutable_initial_env();
  public:
  void unsafe_arena_set_allocated_initial_env(
      ::netsim::bellhop::protobuf::Environment* initial_env);
  ::netsim::bellhop::protobuf::Environment* unsafe_arena_release_initial_env();
 
  // optional bool extrapolate_nav = 6 [default = false, (.goby.field) = {
  bool has_extrapolate_nav() const;
  private:
  bool _internal_has_extrapolate_nav() const;
  public:
  void clear_extrapolate_nav();
  bool extrapolate_nav() const;
  void set_extrapolate_nav(bool value);
  private:
  bool _internal_extrapolate_nav() const;
  void _internal_set_extrapolate_nav(bool value);
  public:
 
  // optional int32 max_number_of_receivers = 10 [default = 1000000];
  bool has_max_number_of_receivers() const;
  private:
  bool _internal_has_max_number_of_receivers() const;
  public:
  void clear_max_number_of_receivers();
  int32_t max_number_of_receivers() const;
  void set_max_number_of_receivers(int32_t value);
  private:
  int32_t _internal_max_number_of_receivers() const;
  void _internal_set_max_number_of_receivers(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.iBellhopConfig)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_moos_var_request_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr moos_var_request_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_moos_var_response_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr moos_var_response_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_output_env_dir_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_env_dir_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_sound_speed_var_;
    ::goby::moos::protobuf::GobyMOOSAppConfig* common_;
    ::netsim::bellhop::protobuf::Environment* initial_env_;
    bool extrapolate_nav_;
    int32_t max_number_of_receivers_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class iBellhopRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.iBellhopRequest) */ {
 public:
  inline iBellhopRequest() : iBellhopRequest(nullptr) {}
  ~iBellhopRequest() override;
  explicit PROTOBUF_CONSTEXPR iBellhopRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  iBellhopRequest(const iBellhopRequest& from);
  iBellhopRequest(iBellhopRequest&& from) noexcept
    : iBellhopRequest() {
    *this = ::std::move(from);
  }
 
  inline iBellhopRequest& operator=(const iBellhopRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline iBellhopRequest& operator=(iBellhopRequest&& 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 iBellhopRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const iBellhopRequest* internal_default_instance() {
    return reinterpret_cast<const iBellhopRequest*>(
               &_iBellhopRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(iBellhopRequest& a, iBellhopRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(iBellhopRequest* 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(iBellhopRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  iBellhopRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iBellhopRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iBellhopRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iBellhopRequest& from) {
    iBellhopRequest::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(iBellhopRequest* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.iBellhopRequest";
  }
  protected:
  explicit iBellhopRequest(::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 iBellhopRequest_WaterColumnAction WaterColumnAction;
  static constexpr WaterColumnAction MERGE_WATER_COLUMNS =
    iBellhopRequest_WaterColumnAction_MERGE_WATER_COLUMNS;
  static constexpr WaterColumnAction MERGE_SAMPLES =
    iBellhopRequest_WaterColumnAction_MERGE_SAMPLES;
  static constexpr WaterColumnAction OVERWRITE =
    iBellhopRequest_WaterColumnAction_OVERWRITE;
  static inline bool WaterColumnAction_IsValid(int value) {
    return iBellhopRequest_WaterColumnAction_IsValid(value);
  }
  static constexpr WaterColumnAction WaterColumnAction_MIN =
    iBellhopRequest_WaterColumnAction_WaterColumnAction_MIN;
  static constexpr WaterColumnAction WaterColumnAction_MAX =
    iBellhopRequest_WaterColumnAction_WaterColumnAction_MAX;
  static constexpr int WaterColumnAction_ARRAYSIZE =
    iBellhopRequest_WaterColumnAction_WaterColumnAction_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  WaterColumnAction_descriptor() {
    return iBellhopRequest_WaterColumnAction_descriptor();
  }
  template<typename T>
  static inline const std::string& WaterColumnAction_Name(T enum_t_value) {
    static_assert(::std::is_same<T, WaterColumnAction>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function WaterColumnAction_Name.");
    return iBellhopRequest_WaterColumnAction_Name(enum_t_value);
  }
  static inline bool WaterColumnAction_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      WaterColumnAction* value) {
    return iBellhopRequest_WaterColumnAction_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kEnvFieldNumber = 1,
    kRequestNumberFieldNumber = 2,
    kWaterColumnActionFieldNumber = 3,
  };
  // required .netsim.bellhop.protobuf.Environment env = 1 [(.goby.field) = {
  bool has_env() const;
  private:
  bool _internal_has_env() const;
  public:
  void clear_env();
  const ::netsim::bellhop::protobuf::Environment& env() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment* release_env();
  ::netsim::bellhop::protobuf::Environment* mutable_env();
  void set_allocated_env(::netsim::bellhop::protobuf::Environment* env);
  private:
  const ::netsim::bellhop::protobuf::Environment& _internal_env() const;
  ::netsim::bellhop::protobuf::Environment* _internal_mutable_env();
  public:
  void unsafe_arena_set_allocated_env(
      ::netsim::bellhop::protobuf::Environment* env);
  ::netsim::bellhop::protobuf::Environment* unsafe_arena_release_env();
 
  // optional int32 request_number = 2 [(.goby.field) = {
  bool has_request_number() const;
  private:
  bool _internal_has_request_number() const;
  public:
  void clear_request_number();
  int32_t request_number() const;
  void set_request_number(int32_t value);
  private:
  int32_t _internal_request_number() const;
  void _internal_set_request_number(int32_t value);
  public:
 
  // optional .netsim.protobuf.iBellhopRequest.WaterColumnAction water_column_action = 3 [default = MERGE_SAMPLES, (.goby.field) = {
  bool has_water_column_action() const;
  private:
  bool _internal_has_water_column_action() const;
  public:
  void clear_water_column_action();
  ::netsim::protobuf::iBellhopRequest_WaterColumnAction water_column_action() const;
  void set_water_column_action(::netsim::protobuf::iBellhopRequest_WaterColumnAction value);
  private:
  ::netsim::protobuf::iBellhopRequest_WaterColumnAction _internal_water_column_action() const;
  void _internal_set_water_column_action(::netsim::protobuf::iBellhopRequest_WaterColumnAction value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.iBellhopRequest)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::netsim::bellhop::protobuf::Environment* env_;
    int32_t request_number_;
    int water_column_action_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class iBellhopResponse_TLAveragedInRange_TLSample final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample) */ {
 public:
  inline iBellhopResponse_TLAveragedInRange_TLSample() : iBellhopResponse_TLAveragedInRange_TLSample(nullptr) {}
  ~iBellhopResponse_TLAveragedInRange_TLSample() override;
  explicit PROTOBUF_CONSTEXPR iBellhopResponse_TLAveragedInRange_TLSample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  iBellhopResponse_TLAveragedInRange_TLSample(const iBellhopResponse_TLAveragedInRange_TLSample& from);
  iBellhopResponse_TLAveragedInRange_TLSample(iBellhopResponse_TLAveragedInRange_TLSample&& from) noexcept
    : iBellhopResponse_TLAveragedInRange_TLSample() {
    *this = ::std::move(from);
  }
 
  inline iBellhopResponse_TLAveragedInRange_TLSample& operator=(const iBellhopResponse_TLAveragedInRange_TLSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline iBellhopResponse_TLAveragedInRange_TLSample& operator=(iBellhopResponse_TLAveragedInRange_TLSample&& 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 iBellhopResponse_TLAveragedInRange_TLSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const iBellhopResponse_TLAveragedInRange_TLSample* internal_default_instance() {
    return reinterpret_cast<const iBellhopResponse_TLAveragedInRange_TLSample*>(
               &_iBellhopResponse_TLAveragedInRange_TLSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(iBellhopResponse_TLAveragedInRange_TLSample& a, iBellhopResponse_TLAveragedInRange_TLSample& b) {
    a.Swap(&b);
  }
  inline void Swap(iBellhopResponse_TLAveragedInRange_TLSample* 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(iBellhopResponse_TLAveragedInRange_TLSample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  iBellhopResponse_TLAveragedInRange_TLSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iBellhopResponse_TLAveragedInRange_TLSample>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iBellhopResponse_TLAveragedInRange_TLSample& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iBellhopResponse_TLAveragedInRange_TLSample& from) {
    iBellhopResponse_TLAveragedInRange_TLSample::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(iBellhopResponse_TLAveragedInRange_TLSample* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample";
  }
  protected:
  explicit iBellhopResponse_TLAveragedInRange_TLSample(::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 {
    kDepthFieldNumber = 1,
    kTlFieldNumber = 2,
  };
  // required double depth = 1;
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // required double tl = 2;
  bool has_tl() const;
  private:
  bool _internal_has_tl() const;
  public:
  void clear_tl();
  double tl() const;
  void set_tl(double value);
  private:
  double _internal_tl() const;
  void _internal_set_tl(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample)
 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_;
    double depth_;
    double tl_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class iBellhopResponse_TLAveragedInRange final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.iBellhopResponse.TLAveragedInRange) */ {
 public:
  inline iBellhopResponse_TLAveragedInRange() : iBellhopResponse_TLAveragedInRange(nullptr) {}
  ~iBellhopResponse_TLAveragedInRange() override;
  explicit PROTOBUF_CONSTEXPR iBellhopResponse_TLAveragedInRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  iBellhopResponse_TLAveragedInRange(const iBellhopResponse_TLAveragedInRange& from);
  iBellhopResponse_TLAveragedInRange(iBellhopResponse_TLAveragedInRange&& from) noexcept
    : iBellhopResponse_TLAveragedInRange() {
    *this = ::std::move(from);
  }
 
  inline iBellhopResponse_TLAveragedInRange& operator=(const iBellhopResponse_TLAveragedInRange& from) {
    CopyFrom(from);
    return *this;
  }
  inline iBellhopResponse_TLAveragedInRange& operator=(iBellhopResponse_TLAveragedInRange&& 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 iBellhopResponse_TLAveragedInRange& default_instance() {
    return *internal_default_instance();
  }
  static inline const iBellhopResponse_TLAveragedInRange* internal_default_instance() {
    return reinterpret_cast<const iBellhopResponse_TLAveragedInRange*>(
               &_iBellhopResponse_TLAveragedInRange_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(iBellhopResponse_TLAveragedInRange& a, iBellhopResponse_TLAveragedInRange& b) {
    a.Swap(&b);
  }
  inline void Swap(iBellhopResponse_TLAveragedInRange* 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(iBellhopResponse_TLAveragedInRange* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  iBellhopResponse_TLAveragedInRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iBellhopResponse_TLAveragedInRange>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iBellhopResponse_TLAveragedInRange& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iBellhopResponse_TLAveragedInRange& from) {
    iBellhopResponse_TLAveragedInRange::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(iBellhopResponse_TLAveragedInRange* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.iBellhopResponse.TLAveragedInRange";
  }
  protected:
  explicit iBellhopResponse_TLAveragedInRange(::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 iBellhopResponse_TLAveragedInRange_TLSample TLSample;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSampleFieldNumber = 1,
  };
  // repeated .netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample sample = 1;
  int sample_size() const;
  private:
  int _internal_sample_size() const;
  public:
  void clear_sample();
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* mutable_sample(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample >*
      mutable_sample();
  private:
  const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample& _internal_sample(int index) const;
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* _internal_add_sample();
  public:
  const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample& sample(int index) const;
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* add_sample();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample >&
      sample() const;
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.iBellhopResponse.TLAveragedInRange)
 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< ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample > sample_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class iBellhopResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.iBellhopResponse) */ {
 public:
  inline iBellhopResponse() : iBellhopResponse(nullptr) {}
  ~iBellhopResponse() override;
  explicit PROTOBUF_CONSTEXPR iBellhopResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  iBellhopResponse(const iBellhopResponse& from);
  iBellhopResponse(iBellhopResponse&& from) noexcept
    : iBellhopResponse() {
    *this = ::std::move(from);
  }
 
  inline iBellhopResponse& operator=(const iBellhopResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline iBellhopResponse& operator=(iBellhopResponse&& 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 iBellhopResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const iBellhopResponse* internal_default_instance() {
    return reinterpret_cast<const iBellhopResponse*>(
               &_iBellhopResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(iBellhopResponse& a, iBellhopResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(iBellhopResponse* 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(iBellhopResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  iBellhopResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<iBellhopResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const iBellhopResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const iBellhopResponse& from) {
    iBellhopResponse::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(iBellhopResponse* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.iBellhopResponse";
  }
  protected:
  explicit iBellhopResponse(::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 iBellhopResponse_TLAveragedInRange TLAveragedInRange;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRequestorFieldNumber = 2,
    kOutputFileFieldNumber = 4,
    kSerializedTlMatrixFieldNumber = 10,
    kEnvFieldNumber = 3,
    kAvgTlFieldNumber = 5,
    kSuccessFieldNumber = 1,
    kRequestNumberFieldNumber = 6,
  };
  // required string requestor = 2 [(.goby.field) = {
  bool has_requestor() const;
  private:
  bool _internal_has_requestor() const;
  public:
  void clear_requestor();
  const std::string& requestor() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_requestor(ArgT0&& arg0, ArgT... args);
  std::string* mutable_requestor();
  PROTOBUF_NODISCARD std::string* release_requestor();
  void set_allocated_requestor(std::string* requestor);
  private:
  const std::string& _internal_requestor() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestor(const std::string& value);
  std::string* _internal_mutable_requestor();
  public:
 
  // optional string output_file = 4 [(.goby.field) = {
  bool has_output_file() const;
  private:
  bool _internal_has_output_file() const;
  public:
  void clear_output_file();
  const std::string& output_file() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_file(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_file();
  PROTOBUF_NODISCARD std::string* release_output_file();
  void set_allocated_output_file(std::string* output_file);
  private:
  const std::string& _internal_output_file() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_file(const std::string& value);
  std::string* _internal_mutable_output_file();
  public:
 
  // optional bytes serialized_tl_matrix = 10 [(.goby.field) = {
  bool has_serialized_tl_matrix() const;
  private:
  bool _internal_has_serialized_tl_matrix() const;
  public:
  void clear_serialized_tl_matrix();
  const std::string& serialized_tl_matrix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serialized_tl_matrix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serialized_tl_matrix();
  PROTOBUF_NODISCARD std::string* release_serialized_tl_matrix();
  void set_allocated_serialized_tl_matrix(std::string* serialized_tl_matrix);
  private:
  const std::string& _internal_serialized_tl_matrix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serialized_tl_matrix(const std::string& value);
  std::string* _internal_mutable_serialized_tl_matrix();
  public:
 
  // optional .netsim.bellhop.protobuf.Environment env = 3 [(.goby.field) = {
  bool has_env() const;
  private:
  bool _internal_has_env() const;
  public:
  void clear_env();
  const ::netsim::bellhop::protobuf::Environment& env() const;
  PROTOBUF_NODISCARD ::netsim::bellhop::protobuf::Environment* release_env();
  ::netsim::bellhop::protobuf::Environment* mutable_env();
  void set_allocated_env(::netsim::bellhop::protobuf::Environment* env);
  private:
  const ::netsim::bellhop::protobuf::Environment& _internal_env() const;
  ::netsim::bellhop::protobuf::Environment* _internal_mutable_env();
  public:
  void unsafe_arena_set_allocated_env(
      ::netsim::bellhop::protobuf::Environment* env);
  ::netsim::bellhop::protobuf::Environment* unsafe_arena_release_env();
 
  // optional .netsim.protobuf.iBellhopResponse.TLAveragedInRange avg_tl = 5 [(.goby.field) = {
  bool has_avg_tl() const;
  private:
  bool _internal_has_avg_tl() const;
  public:
  void clear_avg_tl();
  const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange& avg_tl() const;
  PROTOBUF_NODISCARD ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* release_avg_tl();
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* mutable_avg_tl();
  void set_allocated_avg_tl(::netsim::protobuf::iBellhopResponse_TLAveragedInRange* avg_tl);
  private:
  const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange& _internal_avg_tl() const;
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* _internal_mutable_avg_tl();
  public:
  void unsafe_arena_set_allocated_avg_tl(
      ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* avg_tl);
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* unsafe_arena_release_avg_tl();
 
  // required bool success = 1 [(.goby.field) = {
  bool has_success() const;
  private:
  bool _internal_has_success() const;
  public:
  void clear_success();
  bool success() const;
  void set_success(bool value);
  private:
  bool _internal_success() const;
  void _internal_set_success(bool value);
  public:
 
  // optional int32 request_number = 6 [(.goby.field) = {
  bool has_request_number() const;
  private:
  bool _internal_has_request_number() const;
  public:
  void clear_request_number();
  int32_t request_number() const;
  void set_request_number(int32_t value);
  private:
  int32_t _internal_request_number() const;
  void _internal_set_request_number(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.iBellhopResponse)
 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 requestor_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_file_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serialized_tl_matrix_;
    ::netsim::bellhop::protobuf::Environment* env_;
    ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* avg_tl_;
    bool success_;
    int32_t request_number_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class SVPInfoRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.SVPInfoRequest) */ {
 public:
  inline SVPInfoRequest() : SVPInfoRequest(nullptr) {}
  ~SVPInfoRequest() override;
  explicit PROTOBUF_CONSTEXPR SVPInfoRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SVPInfoRequest(const SVPInfoRequest& from);
  SVPInfoRequest(SVPInfoRequest&& from) noexcept
    : SVPInfoRequest() {
    *this = ::std::move(from);
  }
 
  inline SVPInfoRequest& operator=(const SVPInfoRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SVPInfoRequest& operator=(SVPInfoRequest&& 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 SVPInfoRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const SVPInfoRequest* internal_default_instance() {
    return reinterpret_cast<const SVPInfoRequest*>(
               &_SVPInfoRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(SVPInfoRequest& a, SVPInfoRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SVPInfoRequest* 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(SVPInfoRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SVPInfoRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SVPInfoRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SVPInfoRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SVPInfoRequest& from) {
    SVPInfoRequest::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(SVPInfoRequest* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.SVPInfoRequest";
  }
  protected:
  explicit SVPInfoRequest(::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 {
    kDepthFieldNumber = 1,
  };
  // repeated double depth = 1;
  int depth_size() const;
  private:
  int _internal_depth_size() const;
  public:
  void clear_depth();
  private:
  double _internal_depth(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_depth() const;
  void _internal_add_depth(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_depth();
  public:
  double depth(int index) const;
  void set_depth(int index, double value);
  void add_depth(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      depth() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_depth();
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.SVPInfoRequest)
 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< double > depth_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class SVPInfoResponse_SVPSample final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.SVPInfoResponse.SVPSample) */ {
 public:
  inline SVPInfoResponse_SVPSample() : SVPInfoResponse_SVPSample(nullptr) {}
  ~SVPInfoResponse_SVPSample() override;
  explicit PROTOBUF_CONSTEXPR SVPInfoResponse_SVPSample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SVPInfoResponse_SVPSample(const SVPInfoResponse_SVPSample& from);
  SVPInfoResponse_SVPSample(SVPInfoResponse_SVPSample&& from) noexcept
    : SVPInfoResponse_SVPSample() {
    *this = ::std::move(from);
  }
 
  inline SVPInfoResponse_SVPSample& operator=(const SVPInfoResponse_SVPSample& from) {
    CopyFrom(from);
    return *this;
  }
  inline SVPInfoResponse_SVPSample& operator=(SVPInfoResponse_SVPSample&& 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 SVPInfoResponse_SVPSample& default_instance() {
    return *internal_default_instance();
  }
  static inline const SVPInfoResponse_SVPSample* internal_default_instance() {
    return reinterpret_cast<const SVPInfoResponse_SVPSample*>(
               &_SVPInfoResponse_SVPSample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(SVPInfoResponse_SVPSample& a, SVPInfoResponse_SVPSample& b) {
    a.Swap(&b);
  }
  inline void Swap(SVPInfoResponse_SVPSample* 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(SVPInfoResponse_SVPSample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SVPInfoResponse_SVPSample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SVPInfoResponse_SVPSample>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SVPInfoResponse_SVPSample& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SVPInfoResponse_SVPSample& from) {
    SVPInfoResponse_SVPSample::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(SVPInfoResponse_SVPSample* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.SVPInfoResponse.SVPSample";
  }
  protected:
  explicit SVPInfoResponse_SVPSample(::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 {
    kDepthFieldNumber = 1,
    kSoundSpeedFieldNumber = 2,
  };
  // required double depth = 1;
  bool has_depth() const;
  private:
  bool _internal_has_depth() const;
  public:
  void clear_depth();
  double depth() const;
  void set_depth(double value);
  private:
  double _internal_depth() const;
  void _internal_set_depth(double value);
  public:
 
  // required double sound_speed = 2;
  bool has_sound_speed() const;
  private:
  bool _internal_has_sound_speed() const;
  public:
  void clear_sound_speed();
  double sound_speed() const;
  void set_sound_speed(double value);
  private:
  double _internal_sound_speed() const;
  void _internal_set_sound_speed(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.SVPInfoResponse.SVPSample)
 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_;
    double depth_;
    double sound_speed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// -------------------------------------------------------------------
 
class SVPInfoResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:netsim.protobuf.SVPInfoResponse) */ {
 public:
  inline SVPInfoResponse() : SVPInfoResponse(nullptr) {}
  ~SVPInfoResponse() override;
  explicit PROTOBUF_CONSTEXPR SVPInfoResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SVPInfoResponse(const SVPInfoResponse& from);
  SVPInfoResponse(SVPInfoResponse&& from) noexcept
    : SVPInfoResponse() {
    *this = ::std::move(from);
  }
 
  inline SVPInfoResponse& operator=(const SVPInfoResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline SVPInfoResponse& operator=(SVPInfoResponse&& 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 SVPInfoResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const SVPInfoResponse* internal_default_instance() {
    return reinterpret_cast<const SVPInfoResponse*>(
               &_SVPInfoResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(SVPInfoResponse& a, SVPInfoResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(SVPInfoResponse* 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(SVPInfoResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SVPInfoResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SVPInfoResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SVPInfoResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SVPInfoResponse& from) {
    SVPInfoResponse::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(SVPInfoResponse* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "netsim.protobuf.SVPInfoResponse";
  }
  protected:
  explicit SVPInfoResponse(::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 SVPInfoResponse_SVPSample SVPSample;
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kSvpSampleFieldNumber = 1,
    kSurfaceSoundSpeedFieldNumber = 2,
    kWaterDepthFieldNumber = 3,
    kBottomSoundSpeedFieldNumber = 4,
  };
  // repeated .netsim.protobuf.SVPInfoResponse.SVPSample svp_sample = 1;
  int svp_sample_size() const;
  private:
  int _internal_svp_sample_size() const;
  public:
  void clear_svp_sample();
  ::netsim::protobuf::SVPInfoResponse_SVPSample* mutable_svp_sample(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::SVPInfoResponse_SVPSample >*
      mutable_svp_sample();
  private:
  const ::netsim::protobuf::SVPInfoResponse_SVPSample& _internal_svp_sample(int index) const;
  ::netsim::protobuf::SVPInfoResponse_SVPSample* _internal_add_svp_sample();
  public:
  const ::netsim::protobuf::SVPInfoResponse_SVPSample& svp_sample(int index) const;
  ::netsim::protobuf::SVPInfoResponse_SVPSample* add_svp_sample();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::SVPInfoResponse_SVPSample >&
      svp_sample() const;
 
  // required double surface_sound_speed = 2;
  bool has_surface_sound_speed() const;
  private:
  bool _internal_has_surface_sound_speed() const;
  public:
  void clear_surface_sound_speed();
  double surface_sound_speed() const;
  void set_surface_sound_speed(double value);
  private:
  double _internal_surface_sound_speed() const;
  void _internal_set_surface_sound_speed(double value);
  public:
 
  // optional double water_depth = 3;
  bool has_water_depth() const;
  private:
  bool _internal_has_water_depth() const;
  public:
  void clear_water_depth();
  double water_depth() const;
  void set_water_depth(double value);
  private:
  double _internal_water_depth() const;
  void _internal_set_water_depth(double value);
  public:
 
  // optional double bottom_sound_speed = 4;
  bool has_bottom_sound_speed() const;
  private:
  bool _internal_has_bottom_sound_speed() const;
  public:
  void clear_bottom_sound_speed();
  double bottom_sound_speed() const;
  void set_bottom_sound_speed(double value);
  private:
  double _internal_bottom_sound_speed() const;
  void _internal_set_bottom_sound_speed(double value);
  public:
 
  // @@protoc_insertion_point(class_scope:netsim.protobuf.SVPInfoResponse)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::SVPInfoResponse_SVPSample > svp_sample_;
    double surface_sound_speed_;
    double water_depth_;
    double bottom_sound_speed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// iBellhopConfig
 
// optional .goby.moos.protobuf.GobyMOOSAppConfig common = 1 [(.goby.field) = {
inline bool iBellhopConfig::_internal_has_common() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.common_ != nullptr);
  return value;
}
inline bool iBellhopConfig::has_common() const {
  return _internal_has_common();
}
inline const ::goby::moos::protobuf::GobyMOOSAppConfig& iBellhopConfig::_internal_common() const {
  const ::goby::moos::protobuf::GobyMOOSAppConfig* p = _impl_.common_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::moos::protobuf::GobyMOOSAppConfig&>(
      ::goby::moos::protobuf::_GobyMOOSAppConfig_default_instance_);
}
inline const ::goby::moos::protobuf::GobyMOOSAppConfig& iBellhopConfig::common() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.common)
  return _internal_common();
}
inline void iBellhopConfig::unsafe_arena_set_allocated_common(
    ::goby::moos::protobuf::GobyMOOSAppConfig* common) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.common_);
  }
  _impl_.common_ = common;
  if (common) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.protobuf.iBellhopConfig.common)
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* iBellhopConfig::release_common() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::moos::protobuf::GobyMOOSAppConfig* temp = _impl_.common_;
  _impl_.common_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* iBellhopConfig::unsafe_arena_release_common() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.common)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::goby::moos::protobuf::GobyMOOSAppConfig* temp = _impl_.common_;
  _impl_.common_ = nullptr;
  return temp;
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* iBellhopConfig::_internal_mutable_common() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.common_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::moos::protobuf::GobyMOOSAppConfig>(GetArenaForAllocation());
    _impl_.common_ = p;
  }
  return _impl_.common_;
}
inline ::goby::moos::protobuf::GobyMOOSAppConfig* iBellhopConfig::mutable_common() {
  ::goby::moos::protobuf::GobyMOOSAppConfig* _msg = _internal_mutable_common();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.common)
  return _msg;
}
inline void iBellhopConfig::set_allocated_common(::goby::moos::protobuf::GobyMOOSAppConfig* common) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.common_);
  }
  if (common) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common));
    if (message_arena != submessage_arena) {
      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, common, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.common_ = common;
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.common)
}
 
// required .netsim.bellhop.protobuf.Environment initial_env = 2 [(.goby.field) = {
inline bool iBellhopConfig::_internal_has_initial_env() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.initial_env_ != nullptr);
  return value;
}
inline bool iBellhopConfig::has_initial_env() const {
  return _internal_has_initial_env();
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopConfig::_internal_initial_env() const {
  const ::netsim::bellhop::protobuf::Environment* p = _impl_.initial_env_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment&>(
      ::netsim::bellhop::protobuf::_Environment_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopConfig::initial_env() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.initial_env)
  return _internal_initial_env();
}
inline void iBellhopConfig::unsafe_arena_set_allocated_initial_env(
    ::netsim::bellhop::protobuf::Environment* initial_env) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initial_env_);
  }
  _impl_.initial_env_ = initial_env;
  if (initial_env) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.protobuf.iBellhopConfig.initial_env)
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopConfig::release_initial_env() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.initial_env_;
  _impl_.initial_env_ = 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 ::netsim::bellhop::protobuf::Environment* iBellhopConfig::unsafe_arena_release_initial_env() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.initial_env)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.initial_env_;
  _impl_.initial_env_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopConfig::_internal_mutable_initial_env() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.initial_env_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment>(GetArenaForAllocation());
    _impl_.initial_env_ = p;
  }
  return _impl_.initial_env_;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopConfig::mutable_initial_env() {
  ::netsim::bellhop::protobuf::Environment* _msg = _internal_mutable_initial_env();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.initial_env)
  return _msg;
}
inline void iBellhopConfig::set_allocated_initial_env(::netsim::bellhop::protobuf::Environment* initial_env) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initial_env_);
  }
  if (initial_env) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(initial_env));
    if (message_arena != submessage_arena) {
      initial_env = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, initial_env, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.initial_env_ = initial_env;
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.initial_env)
}
 
// optional string moos_var_request = 3 [default = "BELLHOP_REQUEST", (.goby.field) = {
inline bool iBellhopConfig::_internal_has_moos_var_request() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool iBellhopConfig::has_moos_var_request() const {
  return _internal_has_moos_var_request();
}
inline void iBellhopConfig::clear_moos_var_request() {
  _impl_.moos_var_request_.ClearToDefault(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_moos_var_request_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& iBellhopConfig::moos_var_request() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.moos_var_request)
  if (_impl_.moos_var_request_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_moos_var_request_.get();
  return _internal_moos_var_request();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopConfig::set_moos_var_request(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.moos_var_request_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.moos_var_request)
}
inline std::string* iBellhopConfig::mutable_moos_var_request() {
  std::string* _s = _internal_mutable_moos_var_request();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.moos_var_request)
  return _s;
}
inline const std::string& iBellhopConfig::_internal_moos_var_request() const {
  return _impl_.moos_var_request_.Get();
}
inline void iBellhopConfig::_internal_set_moos_var_request(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.moos_var_request_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::_internal_mutable_moos_var_request() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.moos_var_request_.Mutable(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_moos_var_request_, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::release_moos_var_request() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.moos_var_request)
  if (!_internal_has_moos_var_request()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.moos_var_request_.Release();
  return p;
}
inline void iBellhopConfig::set_allocated_moos_var_request(std::string* moos_var_request) {
  if (moos_var_request != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.moos_var_request_.SetAllocated(moos_var_request, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.moos_var_request)
}
 
// optional string moos_var_response = 4 [default = "BELLHOP_RESPONSE", (.goby.field) = {
inline bool iBellhopConfig::_internal_has_moos_var_response() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool iBellhopConfig::has_moos_var_response() const {
  return _internal_has_moos_var_response();
}
inline void iBellhopConfig::clear_moos_var_response() {
  _impl_.moos_var_response_.ClearToDefault(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_moos_var_response_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& iBellhopConfig::moos_var_response() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.moos_var_response)
  if (_impl_.moos_var_response_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_moos_var_response_.get();
  return _internal_moos_var_response();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopConfig::set_moos_var_response(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.moos_var_response_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.moos_var_response)
}
inline std::string* iBellhopConfig::mutable_moos_var_response() {
  std::string* _s = _internal_mutable_moos_var_response();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.moos_var_response)
  return _s;
}
inline const std::string& iBellhopConfig::_internal_moos_var_response() const {
  return _impl_.moos_var_response_.Get();
}
inline void iBellhopConfig::_internal_set_moos_var_response(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.moos_var_response_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::_internal_mutable_moos_var_response() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.moos_var_response_.Mutable(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_moos_var_response_, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::release_moos_var_response() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.moos_var_response)
  if (!_internal_has_moos_var_response()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.moos_var_response_.Release();
  return p;
}
inline void iBellhopConfig::set_allocated_moos_var_response(std::string* moos_var_response) {
  if (moos_var_response != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.moos_var_response_.SetAllocated(moos_var_response, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.moos_var_response)
}
 
// optional string output_env_dir = 5 [default = "/tmp", (.goby.field) = {
inline bool iBellhopConfig::_internal_has_output_env_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool iBellhopConfig::has_output_env_dir() const {
  return _internal_has_output_env_dir();
}
inline void iBellhopConfig::clear_output_env_dir() {
  _impl_.output_env_dir_.ClearToDefault(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_output_env_dir_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& iBellhopConfig::output_env_dir() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.output_env_dir)
  if (_impl_.output_env_dir_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_output_env_dir_.get();
  return _internal_output_env_dir();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopConfig::set_output_env_dir(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.output_env_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.output_env_dir)
}
inline std::string* iBellhopConfig::mutable_output_env_dir() {
  std::string* _s = _internal_mutable_output_env_dir();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.output_env_dir)
  return _s;
}
inline const std::string& iBellhopConfig::_internal_output_env_dir() const {
  return _impl_.output_env_dir_.Get();
}
inline void iBellhopConfig::_internal_set_output_env_dir(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.output_env_dir_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::_internal_mutable_output_env_dir() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.output_env_dir_.Mutable(::netsim::protobuf::iBellhopConfig::Impl_::_i_give_permission_to_break_this_code_default_output_env_dir_, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::release_output_env_dir() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.output_env_dir)
  if (!_internal_has_output_env_dir()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.output_env_dir_.Release();
  return p;
}
inline void iBellhopConfig::set_allocated_output_env_dir(std::string* output_env_dir) {
  if (output_env_dir != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.output_env_dir_.SetAllocated(output_env_dir, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.output_env_dir)
}
 
// optional bool extrapolate_nav = 6 [default = false, (.goby.field) = {
inline bool iBellhopConfig::_internal_has_extrapolate_nav() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool iBellhopConfig::has_extrapolate_nav() const {
  return _internal_has_extrapolate_nav();
}
inline void iBellhopConfig::clear_extrapolate_nav() {
  _impl_.extrapolate_nav_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool iBellhopConfig::_internal_extrapolate_nav() const {
  return _impl_.extrapolate_nav_;
}
inline bool iBellhopConfig::extrapolate_nav() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.extrapolate_nav)
  return _internal_extrapolate_nav();
}
inline void iBellhopConfig::_internal_set_extrapolate_nav(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.extrapolate_nav_ = value;
}
inline void iBellhopConfig::set_extrapolate_nav(bool value) {
  _internal_set_extrapolate_nav(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.extrapolate_nav)
}
 
// optional string local_sound_speed_var = 7 [(.goby.field) = {
inline bool iBellhopConfig::_internal_has_local_sound_speed_var() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool iBellhopConfig::has_local_sound_speed_var() const {
  return _internal_has_local_sound_speed_var();
}
inline void iBellhopConfig::clear_local_sound_speed_var() {
  _impl_.local_sound_speed_var_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& iBellhopConfig::local_sound_speed_var() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.local_sound_speed_var)
  return _internal_local_sound_speed_var();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopConfig::set_local_sound_speed_var(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.local_sound_speed_var_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.local_sound_speed_var)
}
inline std::string* iBellhopConfig::mutable_local_sound_speed_var() {
  std::string* _s = _internal_mutable_local_sound_speed_var();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopConfig.local_sound_speed_var)
  return _s;
}
inline const std::string& iBellhopConfig::_internal_local_sound_speed_var() const {
  return _impl_.local_sound_speed_var_.Get();
}
inline void iBellhopConfig::_internal_set_local_sound_speed_var(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.local_sound_speed_var_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopConfig::_internal_mutable_local_sound_speed_var() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.local_sound_speed_var_.Mutable(GetArenaForAllocation());
}
inline std::string* iBellhopConfig::release_local_sound_speed_var() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopConfig.local_sound_speed_var)
  if (!_internal_has_local_sound_speed_var()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.local_sound_speed_var_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.local_sound_speed_var_.IsDefault()) {
    _impl_.local_sound_speed_var_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void iBellhopConfig::set_allocated_local_sound_speed_var(std::string* local_sound_speed_var) {
  if (local_sound_speed_var != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.local_sound_speed_var_.SetAllocated(local_sound_speed_var, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.local_sound_speed_var_.IsDefault()) {
    _impl_.local_sound_speed_var_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopConfig.local_sound_speed_var)
}
 
// optional int32 max_number_of_receivers = 10 [default = 1000000];
inline bool iBellhopConfig::_internal_has_max_number_of_receivers() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool iBellhopConfig::has_max_number_of_receivers() const {
  return _internal_has_max_number_of_receivers();
}
inline void iBellhopConfig::clear_max_number_of_receivers() {
  _impl_.max_number_of_receivers_ = 1000000;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t iBellhopConfig::_internal_max_number_of_receivers() const {
  return _impl_.max_number_of_receivers_;
}
inline int32_t iBellhopConfig::max_number_of_receivers() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopConfig.max_number_of_receivers)
  return _internal_max_number_of_receivers();
}
inline void iBellhopConfig::_internal_set_max_number_of_receivers(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.max_number_of_receivers_ = value;
}
inline void iBellhopConfig::set_max_number_of_receivers(int32_t value) {
  _internal_set_max_number_of_receivers(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopConfig.max_number_of_receivers)
}
 
// -------------------------------------------------------------------
 
// iBellhopRequest
 
// required .netsim.bellhop.protobuf.Environment env = 1 [(.goby.field) = {
inline bool iBellhopRequest::_internal_has_env() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.env_ != nullptr);
  return value;
}
inline bool iBellhopRequest::has_env() const {
  return _internal_has_env();
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopRequest::_internal_env() const {
  const ::netsim::bellhop::protobuf::Environment* p = _impl_.env_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment&>(
      ::netsim::bellhop::protobuf::_Environment_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopRequest::env() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopRequest.env)
  return _internal_env();
}
inline void iBellhopRequest::unsafe_arena_set_allocated_env(
    ::netsim::bellhop::protobuf::Environment* env) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.env_);
  }
  _impl_.env_ = env;
  if (env) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.protobuf.iBellhopRequest.env)
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopRequest::release_env() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.env_;
  _impl_.env_ = 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 ::netsim::bellhop::protobuf::Environment* iBellhopRequest::unsafe_arena_release_env() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopRequest.env)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.env_;
  _impl_.env_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopRequest::_internal_mutable_env() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.env_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment>(GetArenaForAllocation());
    _impl_.env_ = p;
  }
  return _impl_.env_;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopRequest::mutable_env() {
  ::netsim::bellhop::protobuf::Environment* _msg = _internal_mutable_env();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopRequest.env)
  return _msg;
}
inline void iBellhopRequest::set_allocated_env(::netsim::bellhop::protobuf::Environment* env) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.env_);
  }
  if (env) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(env));
    if (message_arena != submessage_arena) {
      env = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, env, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.env_ = env;
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopRequest.env)
}
 
// optional int32 request_number = 2 [(.goby.field) = {
inline bool iBellhopRequest::_internal_has_request_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool iBellhopRequest::has_request_number() const {
  return _internal_has_request_number();
}
inline void iBellhopRequest::clear_request_number() {
  _impl_.request_number_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t iBellhopRequest::_internal_request_number() const {
  return _impl_.request_number_;
}
inline int32_t iBellhopRequest::request_number() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopRequest.request_number)
  return _internal_request_number();
}
inline void iBellhopRequest::_internal_set_request_number(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.request_number_ = value;
}
inline void iBellhopRequest::set_request_number(int32_t value) {
  _internal_set_request_number(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopRequest.request_number)
}
 
// optional .netsim.protobuf.iBellhopRequest.WaterColumnAction water_column_action = 3 [default = MERGE_SAMPLES, (.goby.field) = {
inline bool iBellhopRequest::_internal_has_water_column_action() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool iBellhopRequest::has_water_column_action() const {
  return _internal_has_water_column_action();
}
inline void iBellhopRequest::clear_water_column_action() {
  _impl_.water_column_action_ = 2;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::netsim::protobuf::iBellhopRequest_WaterColumnAction iBellhopRequest::_internal_water_column_action() const {
  return static_cast< ::netsim::protobuf::iBellhopRequest_WaterColumnAction >(_impl_.water_column_action_);
}
inline ::netsim::protobuf::iBellhopRequest_WaterColumnAction iBellhopRequest::water_column_action() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopRequest.water_column_action)
  return _internal_water_column_action();
}
inline void iBellhopRequest::_internal_set_water_column_action(::netsim::protobuf::iBellhopRequest_WaterColumnAction value) {
  assert(::netsim::protobuf::iBellhopRequest_WaterColumnAction_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.water_column_action_ = value;
}
inline void iBellhopRequest::set_water_column_action(::netsim::protobuf::iBellhopRequest_WaterColumnAction value) {
  _internal_set_water_column_action(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopRequest.water_column_action)
}
 
// -------------------------------------------------------------------
 
// iBellhopResponse_TLAveragedInRange_TLSample
 
// required double depth = 1;
inline bool iBellhopResponse_TLAveragedInRange_TLSample::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool iBellhopResponse_TLAveragedInRange_TLSample::has_depth() const {
  return _internal_has_depth();
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double iBellhopResponse_TLAveragedInRange_TLSample::_internal_depth() const {
  return _impl_.depth_;
}
inline double iBellhopResponse_TLAveragedInRange_TLSample::depth() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample.depth)
  return _internal_depth();
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.depth_ = value;
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample.depth)
}
 
// required double tl = 2;
inline bool iBellhopResponse_TLAveragedInRange_TLSample::_internal_has_tl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool iBellhopResponse_TLAveragedInRange_TLSample::has_tl() const {
  return _internal_has_tl();
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::clear_tl() {
  _impl_.tl_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double iBellhopResponse_TLAveragedInRange_TLSample::_internal_tl() const {
  return _impl_.tl_;
}
inline double iBellhopResponse_TLAveragedInRange_TLSample::tl() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample.tl)
  return _internal_tl();
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::_internal_set_tl(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.tl_ = value;
}
inline void iBellhopResponse_TLAveragedInRange_TLSample::set_tl(double value) {
  _internal_set_tl(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample.tl)
}
 
// -------------------------------------------------------------------
 
// iBellhopResponse_TLAveragedInRange
 
// repeated .netsim.protobuf.iBellhopResponse.TLAveragedInRange.TLSample sample = 1;
inline int iBellhopResponse_TLAveragedInRange::_internal_sample_size() const {
  return _impl_.sample_.size();
}
inline int iBellhopResponse_TLAveragedInRange::sample_size() const {
  return _internal_sample_size();
}
inline void iBellhopResponse_TLAveragedInRange::clear_sample() {
  _impl_.sample_.Clear();
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* iBellhopResponse_TLAveragedInRange::mutable_sample(int index) {
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.TLAveragedInRange.sample)
  return _impl_.sample_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample >*
iBellhopResponse_TLAveragedInRange::mutable_sample() {
  // @@protoc_insertion_point(field_mutable_list:netsim.protobuf.iBellhopResponse.TLAveragedInRange.sample)
  return &_impl_.sample_;
}
inline const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample& iBellhopResponse_TLAveragedInRange::_internal_sample(int index) const {
  return _impl_.sample_.Get(index);
}
inline const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample& iBellhopResponse_TLAveragedInRange::sample(int index) const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.TLAveragedInRange.sample)
  return _internal_sample(index);
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* iBellhopResponse_TLAveragedInRange::_internal_add_sample() {
  return _impl_.sample_.Add();
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* iBellhopResponse_TLAveragedInRange::add_sample() {
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample* _add = _internal_add_sample();
  // @@protoc_insertion_point(field_add:netsim.protobuf.iBellhopResponse.TLAveragedInRange.sample)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::iBellhopResponse_TLAveragedInRange_TLSample >&
iBellhopResponse_TLAveragedInRange::sample() const {
  // @@protoc_insertion_point(field_list:netsim.protobuf.iBellhopResponse.TLAveragedInRange.sample)
  return _impl_.sample_;
}
 
// -------------------------------------------------------------------
 
// iBellhopResponse
 
// required bool success = 1 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_success() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool iBellhopResponse::has_success() const {
  return _internal_has_success();
}
inline void iBellhopResponse::clear_success() {
  _impl_.success_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool iBellhopResponse::_internal_success() const {
  return _impl_.success_;
}
inline bool iBellhopResponse::success() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.success)
  return _internal_success();
}
inline void iBellhopResponse::_internal_set_success(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.success_ = value;
}
inline void iBellhopResponse::set_success(bool value) {
  _internal_set_success(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.success)
}
 
// required string requestor = 2 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_requestor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool iBellhopResponse::has_requestor() const {
  return _internal_has_requestor();
}
inline void iBellhopResponse::clear_requestor() {
  _impl_.requestor_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& iBellhopResponse::requestor() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.requestor)
  return _internal_requestor();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopResponse::set_requestor(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.requestor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.requestor)
}
inline std::string* iBellhopResponse::mutable_requestor() {
  std::string* _s = _internal_mutable_requestor();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.requestor)
  return _s;
}
inline const std::string& iBellhopResponse::_internal_requestor() const {
  return _impl_.requestor_.Get();
}
inline void iBellhopResponse::_internal_set_requestor(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.requestor_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopResponse::_internal_mutable_requestor() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.requestor_.Mutable(GetArenaForAllocation());
}
inline std::string* iBellhopResponse::release_requestor() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopResponse.requestor)
  if (!_internal_has_requestor()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.requestor_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.requestor_.IsDefault()) {
    _impl_.requestor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void iBellhopResponse::set_allocated_requestor(std::string* requestor) {
  if (requestor != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.requestor_.SetAllocated(requestor, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.requestor_.IsDefault()) {
    _impl_.requestor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopResponse.requestor)
}
 
// optional .netsim.bellhop.protobuf.Environment env = 3 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_env() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.env_ != nullptr);
  return value;
}
inline bool iBellhopResponse::has_env() const {
  return _internal_has_env();
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopResponse::_internal_env() const {
  const ::netsim::bellhop::protobuf::Environment* p = _impl_.env_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::bellhop::protobuf::Environment&>(
      ::netsim::bellhop::protobuf::_Environment_default_instance_);
}
inline const ::netsim::bellhop::protobuf::Environment& iBellhopResponse::env() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.env)
  return _internal_env();
}
inline void iBellhopResponse::unsafe_arena_set_allocated_env(
    ::netsim::bellhop::protobuf::Environment* env) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.env_);
  }
  _impl_.env_ = env;
  if (env) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.protobuf.iBellhopResponse.env)
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopResponse::release_env() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.env_;
  _impl_.env_ = 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 ::netsim::bellhop::protobuf::Environment* iBellhopResponse::unsafe_arena_release_env() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopResponse.env)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::netsim::bellhop::protobuf::Environment* temp = _impl_.env_;
  _impl_.env_ = nullptr;
  return temp;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopResponse::_internal_mutable_env() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.env_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::bellhop::protobuf::Environment>(GetArenaForAllocation());
    _impl_.env_ = p;
  }
  return _impl_.env_;
}
inline ::netsim::bellhop::protobuf::Environment* iBellhopResponse::mutable_env() {
  ::netsim::bellhop::protobuf::Environment* _msg = _internal_mutable_env();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.env)
  return _msg;
}
inline void iBellhopResponse::set_allocated_env(::netsim::bellhop::protobuf::Environment* env) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.env_);
  }
  if (env) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(env));
    if (message_arena != submessage_arena) {
      env = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, env, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.env_ = env;
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopResponse.env)
}
 
// optional string output_file = 4 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_output_file() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool iBellhopResponse::has_output_file() const {
  return _internal_has_output_file();
}
inline void iBellhopResponse::clear_output_file() {
  _impl_.output_file_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& iBellhopResponse::output_file() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.output_file)
  return _internal_output_file();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopResponse::set_output_file(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.output_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.output_file)
}
inline std::string* iBellhopResponse::mutable_output_file() {
  std::string* _s = _internal_mutable_output_file();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.output_file)
  return _s;
}
inline const std::string& iBellhopResponse::_internal_output_file() const {
  return _impl_.output_file_.Get();
}
inline void iBellhopResponse::_internal_set_output_file(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.output_file_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopResponse::_internal_mutable_output_file() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.output_file_.Mutable(GetArenaForAllocation());
}
inline std::string* iBellhopResponse::release_output_file() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopResponse.output_file)
  if (!_internal_has_output_file()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.output_file_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_file_.IsDefault()) {
    _impl_.output_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void iBellhopResponse::set_allocated_output_file(std::string* output_file) {
  if (output_file != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.output_file_.SetAllocated(output_file, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_file_.IsDefault()) {
    _impl_.output_file_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopResponse.output_file)
}
 
// optional .netsim.protobuf.iBellhopResponse.TLAveragedInRange avg_tl = 5 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_avg_tl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.avg_tl_ != nullptr);
  return value;
}
inline bool iBellhopResponse::has_avg_tl() const {
  return _internal_has_avg_tl();
}
inline void iBellhopResponse::clear_avg_tl() {
  if (_impl_.avg_tl_ != nullptr) _impl_.avg_tl_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange& iBellhopResponse::_internal_avg_tl() const {
  const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* p = _impl_.avg_tl_;
  return p != nullptr ? *p : reinterpret_cast<const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange&>(
      ::netsim::protobuf::_iBellhopResponse_TLAveragedInRange_default_instance_);
}
inline const ::netsim::protobuf::iBellhopResponse_TLAveragedInRange& iBellhopResponse::avg_tl() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.avg_tl)
  return _internal_avg_tl();
}
inline void iBellhopResponse::unsafe_arena_set_allocated_avg_tl(
    ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* avg_tl) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.avg_tl_);
  }
  _impl_.avg_tl_ = avg_tl;
  if (avg_tl) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:netsim.protobuf.iBellhopResponse.avg_tl)
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* iBellhopResponse::release_avg_tl() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* temp = _impl_.avg_tl_;
  _impl_.avg_tl_ = 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 ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* iBellhopResponse::unsafe_arena_release_avg_tl() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopResponse.avg_tl)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* temp = _impl_.avg_tl_;
  _impl_.avg_tl_ = nullptr;
  return temp;
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* iBellhopResponse::_internal_mutable_avg_tl() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.avg_tl_ == nullptr) {
    auto* p = CreateMaybeMessage<::netsim::protobuf::iBellhopResponse_TLAveragedInRange>(GetArenaForAllocation());
    _impl_.avg_tl_ = p;
  }
  return _impl_.avg_tl_;
}
inline ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* iBellhopResponse::mutable_avg_tl() {
  ::netsim::protobuf::iBellhopResponse_TLAveragedInRange* _msg = _internal_mutable_avg_tl();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.avg_tl)
  return _msg;
}
inline void iBellhopResponse::set_allocated_avg_tl(::netsim::protobuf::iBellhopResponse_TLAveragedInRange* avg_tl) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.avg_tl_;
  }
  if (avg_tl) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(avg_tl);
    if (message_arena != submessage_arena) {
      avg_tl = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, avg_tl, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.avg_tl_ = avg_tl;
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopResponse.avg_tl)
}
 
// optional bytes serialized_tl_matrix = 10 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_serialized_tl_matrix() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool iBellhopResponse::has_serialized_tl_matrix() const {
  return _internal_has_serialized_tl_matrix();
}
inline void iBellhopResponse::clear_serialized_tl_matrix() {
  _impl_.serialized_tl_matrix_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& iBellhopResponse::serialized_tl_matrix() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.serialized_tl_matrix)
  return _internal_serialized_tl_matrix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void iBellhopResponse::set_serialized_tl_matrix(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.serialized_tl_matrix_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.serialized_tl_matrix)
}
inline std::string* iBellhopResponse::mutable_serialized_tl_matrix() {
  std::string* _s = _internal_mutable_serialized_tl_matrix();
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.iBellhopResponse.serialized_tl_matrix)
  return _s;
}
inline const std::string& iBellhopResponse::_internal_serialized_tl_matrix() const {
  return _impl_.serialized_tl_matrix_.Get();
}
inline void iBellhopResponse::_internal_set_serialized_tl_matrix(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.serialized_tl_matrix_.Set(value, GetArenaForAllocation());
}
inline std::string* iBellhopResponse::_internal_mutable_serialized_tl_matrix() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.serialized_tl_matrix_.Mutable(GetArenaForAllocation());
}
inline std::string* iBellhopResponse::release_serialized_tl_matrix() {
  // @@protoc_insertion_point(field_release:netsim.protobuf.iBellhopResponse.serialized_tl_matrix)
  if (!_internal_has_serialized_tl_matrix()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.serialized_tl_matrix_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serialized_tl_matrix_.IsDefault()) {
    _impl_.serialized_tl_matrix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void iBellhopResponse::set_allocated_serialized_tl_matrix(std::string* serialized_tl_matrix) {
  if (serialized_tl_matrix != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.serialized_tl_matrix_.SetAllocated(serialized_tl_matrix, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serialized_tl_matrix_.IsDefault()) {
    _impl_.serialized_tl_matrix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:netsim.protobuf.iBellhopResponse.serialized_tl_matrix)
}
 
// optional int32 request_number = 6 [(.goby.field) = {
inline bool iBellhopResponse::_internal_has_request_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool iBellhopResponse::has_request_number() const {
  return _internal_has_request_number();
}
inline void iBellhopResponse::clear_request_number() {
  _impl_.request_number_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t iBellhopResponse::_internal_request_number() const {
  return _impl_.request_number_;
}
inline int32_t iBellhopResponse::request_number() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.iBellhopResponse.request_number)
  return _internal_request_number();
}
inline void iBellhopResponse::_internal_set_request_number(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.request_number_ = value;
}
inline void iBellhopResponse::set_request_number(int32_t value) {
  _internal_set_request_number(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.iBellhopResponse.request_number)
}
 
// -------------------------------------------------------------------
 
// SVPInfoRequest
 
// repeated double depth = 1;
inline int SVPInfoRequest::_internal_depth_size() const {
  return _impl_.depth_.size();
}
inline int SVPInfoRequest::depth_size() const {
  return _internal_depth_size();
}
inline void SVPInfoRequest::clear_depth() {
  _impl_.depth_.Clear();
}
inline double SVPInfoRequest::_internal_depth(int index) const {
  return _impl_.depth_.Get(index);
}
inline double SVPInfoRequest::depth(int index) const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoRequest.depth)
  return _internal_depth(index);
}
inline void SVPInfoRequest::set_depth(int index, double value) {
  _impl_.depth_.Set(index, value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoRequest.depth)
}
inline void SVPInfoRequest::_internal_add_depth(double value) {
  _impl_.depth_.Add(value);
}
inline void SVPInfoRequest::add_depth(double value) {
  _internal_add_depth(value);
  // @@protoc_insertion_point(field_add:netsim.protobuf.SVPInfoRequest.depth)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SVPInfoRequest::_internal_depth() const {
  return _impl_.depth_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SVPInfoRequest::depth() const {
  // @@protoc_insertion_point(field_list:netsim.protobuf.SVPInfoRequest.depth)
  return _internal_depth();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SVPInfoRequest::_internal_mutable_depth() {
  return &_impl_.depth_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SVPInfoRequest::mutable_depth() {
  // @@protoc_insertion_point(field_mutable_list:netsim.protobuf.SVPInfoRequest.depth)
  return _internal_mutable_depth();
}
 
// -------------------------------------------------------------------
 
// SVPInfoResponse_SVPSample
 
// required double depth = 1;
inline bool SVPInfoResponse_SVPSample::_internal_has_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SVPInfoResponse_SVPSample::has_depth() const {
  return _internal_has_depth();
}
inline void SVPInfoResponse_SVPSample::clear_depth() {
  _impl_.depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double SVPInfoResponse_SVPSample::_internal_depth() const {
  return _impl_.depth_;
}
inline double SVPInfoResponse_SVPSample::depth() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.SVPSample.depth)
  return _internal_depth();
}
inline void SVPInfoResponse_SVPSample::_internal_set_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.depth_ = value;
}
inline void SVPInfoResponse_SVPSample::set_depth(double value) {
  _internal_set_depth(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoResponse.SVPSample.depth)
}
 
// required double sound_speed = 2;
inline bool SVPInfoResponse_SVPSample::_internal_has_sound_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SVPInfoResponse_SVPSample::has_sound_speed() const {
  return _internal_has_sound_speed();
}
inline void SVPInfoResponse_SVPSample::clear_sound_speed() {
  _impl_.sound_speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double SVPInfoResponse_SVPSample::_internal_sound_speed() const {
  return _impl_.sound_speed_;
}
inline double SVPInfoResponse_SVPSample::sound_speed() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.SVPSample.sound_speed)
  return _internal_sound_speed();
}
inline void SVPInfoResponse_SVPSample::_internal_set_sound_speed(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.sound_speed_ = value;
}
inline void SVPInfoResponse_SVPSample::set_sound_speed(double value) {
  _internal_set_sound_speed(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoResponse.SVPSample.sound_speed)
}
 
// -------------------------------------------------------------------
 
// SVPInfoResponse
 
// repeated .netsim.protobuf.SVPInfoResponse.SVPSample svp_sample = 1;
inline int SVPInfoResponse::_internal_svp_sample_size() const {
  return _impl_.svp_sample_.size();
}
inline int SVPInfoResponse::svp_sample_size() const {
  return _internal_svp_sample_size();
}
inline void SVPInfoResponse::clear_svp_sample() {
  _impl_.svp_sample_.Clear();
}
inline ::netsim::protobuf::SVPInfoResponse_SVPSample* SVPInfoResponse::mutable_svp_sample(int index) {
  // @@protoc_insertion_point(field_mutable:netsim.protobuf.SVPInfoResponse.svp_sample)
  return _impl_.svp_sample_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::SVPInfoResponse_SVPSample >*
SVPInfoResponse::mutable_svp_sample() {
  // @@protoc_insertion_point(field_mutable_list:netsim.protobuf.SVPInfoResponse.svp_sample)
  return &_impl_.svp_sample_;
}
inline const ::netsim::protobuf::SVPInfoResponse_SVPSample& SVPInfoResponse::_internal_svp_sample(int index) const {
  return _impl_.svp_sample_.Get(index);
}
inline const ::netsim::protobuf::SVPInfoResponse_SVPSample& SVPInfoResponse::svp_sample(int index) const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.svp_sample)
  return _internal_svp_sample(index);
}
inline ::netsim::protobuf::SVPInfoResponse_SVPSample* SVPInfoResponse::_internal_add_svp_sample() {
  return _impl_.svp_sample_.Add();
}
inline ::netsim::protobuf::SVPInfoResponse_SVPSample* SVPInfoResponse::add_svp_sample() {
  ::netsim::protobuf::SVPInfoResponse_SVPSample* _add = _internal_add_svp_sample();
  // @@protoc_insertion_point(field_add:netsim.protobuf.SVPInfoResponse.svp_sample)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::netsim::protobuf::SVPInfoResponse_SVPSample >&
SVPInfoResponse::svp_sample() const {
  // @@protoc_insertion_point(field_list:netsim.protobuf.SVPInfoResponse.svp_sample)
  return _impl_.svp_sample_;
}
 
// required double surface_sound_speed = 2;
inline bool SVPInfoResponse::_internal_has_surface_sound_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SVPInfoResponse::has_surface_sound_speed() const {
  return _internal_has_surface_sound_speed();
}
inline void SVPInfoResponse::clear_surface_sound_speed() {
  _impl_.surface_sound_speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline double SVPInfoResponse::_internal_surface_sound_speed() const {
  return _impl_.surface_sound_speed_;
}
inline double SVPInfoResponse::surface_sound_speed() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.surface_sound_speed)
  return _internal_surface_sound_speed();
}
inline void SVPInfoResponse::_internal_set_surface_sound_speed(double value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.surface_sound_speed_ = value;
}
inline void SVPInfoResponse::set_surface_sound_speed(double value) {
  _internal_set_surface_sound_speed(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoResponse.surface_sound_speed)
}
 
// optional double water_depth = 3;
inline bool SVPInfoResponse::_internal_has_water_depth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SVPInfoResponse::has_water_depth() const {
  return _internal_has_water_depth();
}
inline void SVPInfoResponse::clear_water_depth() {
  _impl_.water_depth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double SVPInfoResponse::_internal_water_depth() const {
  return _impl_.water_depth_;
}
inline double SVPInfoResponse::water_depth() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.water_depth)
  return _internal_water_depth();
}
inline void SVPInfoResponse::_internal_set_water_depth(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.water_depth_ = value;
}
inline void SVPInfoResponse::set_water_depth(double value) {
  _internal_set_water_depth(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoResponse.water_depth)
}
 
// optional double bottom_sound_speed = 4;
inline bool SVPInfoResponse::_internal_has_bottom_sound_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SVPInfoResponse::has_bottom_sound_speed() const {
  return _internal_has_bottom_sound_speed();
}
inline void SVPInfoResponse::clear_bottom_sound_speed() {
  _impl_.bottom_sound_speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double SVPInfoResponse::_internal_bottom_sound_speed() const {
  return _impl_.bottom_sound_speed_;
}
inline double SVPInfoResponse::bottom_sound_speed() const {
  // @@protoc_insertion_point(field_get:netsim.protobuf.SVPInfoResponse.bottom_sound_speed)
  return _internal_bottom_sound_speed();
}
inline void SVPInfoResponse::_internal_set_bottom_sound_speed(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bottom_sound_speed_ = value;
}
inline void SVPInfoResponse::set_bottom_sound_speed(double value) {
  _internal_set_bottom_sound_speed(value);
  // @@protoc_insertion_point(field_set:netsim.protobuf.SVPInfoResponse.bottom_sound_speed)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace netsim
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::netsim::protobuf::iBellhopRequest_WaterColumnAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::netsim::protobuf::iBellhopRequest_WaterColumnAction>() {
  return ::netsim::protobuf::iBellhopRequest_WaterColumnAction_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_netsim_2facousticstoolbox_2fiBellhop_5fmessages_2eproto