frontseat.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/middleware/protobuf/frontseat.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "goby/middleware/protobuf/frontseat_data.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
namespace goby {
namespace middleware {
namespace frontseat {
namespace protobuf {
class CommandRequest;
struct CommandRequestDefaultTypeInternal;
extern CommandRequestDefaultTypeInternal _CommandRequest_default_instance_;
class CommandResponse;
struct CommandResponseDefaultTypeInternal;
extern CommandResponseDefaultTypeInternal _CommandResponse_default_instance_;
class HelmStateReport;
struct HelmStateReportDefaultTypeInternal;
extern HelmStateReportDefaultTypeInternal _HelmStateReport_default_instance_;
class InterfaceData;
struct InterfaceDataDefaultTypeInternal;
extern InterfaceDataDefaultTypeInternal _InterfaceData_default_instance_;
class InterfaceStatus;
struct InterfaceStatusDefaultTypeInternal;
extern InterfaceStatusDefaultTypeInternal _InterfaceStatus_default_instance_;
class Raw;
struct RawDefaultTypeInternal;
extern RawDefaultTypeInternal _Raw_default_instance_;
}  // namespace protobuf
}  // namespace frontseat
}  // namespace middleware
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::middleware::frontseat::protobuf::CommandRequest* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::CommandRequest>(Arena*);
template<> ::goby::middleware::frontseat::protobuf::CommandResponse* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::CommandResponse>(Arena*);
template<> ::goby::middleware::frontseat::protobuf::HelmStateReport* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::HelmStateReport>(Arena*);
template<> ::goby::middleware::frontseat::protobuf::InterfaceData* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::InterfaceData>(Arena*);
template<> ::goby::middleware::frontseat::protobuf::InterfaceStatus* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::InterfaceStatus>(Arena*);
template<> ::goby::middleware::frontseat::protobuf::Raw* Arena::CreateMaybeMessage<::goby::middleware::frontseat::protobuf::Raw>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace middleware {
namespace frontseat {
namespace protobuf {
 
enum Raw_RawType : int {
  Raw_RawType_RAW_ASCII = 1,
  Raw_RawType_RAW_BINARY = 2
};
bool Raw_RawType_IsValid(int value);
constexpr Raw_RawType Raw_RawType_RawType_MIN = Raw_RawType_RAW_ASCII;
constexpr Raw_RawType Raw_RawType_RawType_MAX = Raw_RawType_RAW_BINARY;
constexpr int Raw_RawType_RawType_ARRAYSIZE = Raw_RawType_RawType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Raw_RawType_descriptor();
template<typename T>
inline const std::string& Raw_RawType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Raw_RawType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Raw_RawType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Raw_RawType_descriptor(), enum_t_value);
}
inline bool Raw_RawType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Raw_RawType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Raw_RawType>(
    Raw_RawType_descriptor(), name, value);
}
enum InterfaceState : int {
  INTERFACE_STANDBY = 1,
  INTERFACE_LISTEN = 2,
  INTERFACE_COMMAND = 3,
  INTERFACE_HELM_ERROR = 4,
  INTERFACE_FS_ERROR = 5
};
bool InterfaceState_IsValid(int value);
constexpr InterfaceState InterfaceState_MIN = INTERFACE_STANDBY;
constexpr InterfaceState InterfaceState_MAX = INTERFACE_FS_ERROR;
constexpr int InterfaceState_ARRAYSIZE = InterfaceState_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* InterfaceState_descriptor();
template<typename T>
inline const std::string& InterfaceState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, InterfaceState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function InterfaceState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    InterfaceState_descriptor(), enum_t_value);
}
inline bool InterfaceState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InterfaceState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<InterfaceState>(
    InterfaceState_descriptor(), name, value);
}
enum FrontSeatState : int {
  FRONTSEAT_NOT_CONNECTED = 0,
  FRONTSEAT_IDLE = 1,
  FRONTSEAT_ACCEPTING_COMMANDS = 2,
  FRONTSEAT_IN_CONTROL = 3
};
bool FrontSeatState_IsValid(int value);
constexpr FrontSeatState FrontSeatState_MIN = FRONTSEAT_NOT_CONNECTED;
constexpr FrontSeatState FrontSeatState_MAX = FRONTSEAT_IN_CONTROL;
constexpr int FrontSeatState_ARRAYSIZE = FrontSeatState_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FrontSeatState_descriptor();
template<typename T>
inline const std::string& FrontSeatState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FrontSeatState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FrontSeatState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FrontSeatState_descriptor(), enum_t_value);
}
inline bool FrontSeatState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FrontSeatState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FrontSeatState>(
    FrontSeatState_descriptor(), name, value);
}
enum HelmState : int {
  HELM_NOT_RUNNING = 0,
  HELM_DRIVE = 1,
  HELM_PARK = 2
};
bool HelmState_IsValid(int value);
constexpr HelmState HelmState_MIN = HELM_NOT_RUNNING;
constexpr HelmState HelmState_MAX = HELM_PARK;
constexpr int HelmState_ARRAYSIZE = HelmState_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HelmState_descriptor();
template<typename T>
inline const std::string& HelmState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HelmState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HelmState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HelmState_descriptor(), enum_t_value);
}
inline bool HelmState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HelmState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HelmState>(
    HelmState_descriptor(), name, value);
}
enum HelmError : int {
  ERROR_HELM_NONE = 0,
  ERROR_HELM_NOT_RUNNING = 1,
  ERROR_HELM_PARKED = 2
};
bool HelmError_IsValid(int value);
constexpr HelmError HelmError_MIN = ERROR_HELM_NONE;
constexpr HelmError HelmError_MAX = ERROR_HELM_PARKED;
constexpr int HelmError_ARRAYSIZE = HelmError_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HelmError_descriptor();
template<typename T>
inline const std::string& HelmError_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HelmError>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HelmError_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HelmError_descriptor(), enum_t_value);
}
inline bool HelmError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HelmError* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HelmError>(
    HelmError_descriptor(), name, value);
}
enum FrontSeatError : int {
  ERROR_FRONTSEAT_NONE = 0,
  ERROR_FRONTSEAT_NOT_CONNECTED = 1,
  ERROR_FRONTSEAT_NOT_PROVIDING_DATA = 2,
  ERROR_FRONTSEAT_IGNORING_COMMANDS = 3
};
bool FrontSeatError_IsValid(int value);
constexpr FrontSeatError FrontSeatError_MIN = ERROR_FRONTSEAT_NONE;
constexpr FrontSeatError FrontSeatError_MAX = ERROR_FRONTSEAT_IGNORING_COMMANDS;
constexpr int FrontSeatError_ARRAYSIZE = FrontSeatError_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FrontSeatError_descriptor();
template<typename T>
inline const std::string& FrontSeatError_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FrontSeatError>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FrontSeatError_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FrontSeatError_descriptor(), enum_t_value);
}
inline bool FrontSeatError_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FrontSeatError* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FrontSeatError>(
    FrontSeatError_descriptor(), name, value);
}
// ===================================================================
 
class HelmStateReport final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.HelmStateReport) */ {
 public:
  inline HelmStateReport() : HelmStateReport(nullptr) {}
  ~HelmStateReport() override;
  explicit PROTOBUF_CONSTEXPR HelmStateReport(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  HelmStateReport(const HelmStateReport& from);
  HelmStateReport(HelmStateReport&& from) noexcept
    : HelmStateReport() {
    *this = ::std::move(from);
  }
 
  inline HelmStateReport& operator=(const HelmStateReport& from) {
    CopyFrom(from);
    return *this;
  }
  inline HelmStateReport& operator=(HelmStateReport&& 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 HelmStateReport& default_instance() {
    return *internal_default_instance();
  }
  static inline const HelmStateReport* internal_default_instance() {
    return reinterpret_cast<const HelmStateReport*>(
               &_HelmStateReport_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(HelmStateReport& a, HelmStateReport& b) {
    a.Swap(&b);
  }
  inline void Swap(HelmStateReport* 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(HelmStateReport* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  HelmStateReport* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HelmStateReport>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HelmStateReport& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HelmStateReport& from) {
    HelmStateReport::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(HelmStateReport* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.HelmStateReport";
  }
  protected:
  explicit HelmStateReport(::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 {
    kStateFieldNumber = 1,
  };
  // required .goby.middleware.frontseat.protobuf.HelmState state = 1;
  bool has_state() const;
  private:
  bool _internal_has_state() const;
  public:
  void clear_state();
  ::goby::middleware::frontseat::protobuf::HelmState state() const;
  void set_state(::goby::middleware::frontseat::protobuf::HelmState value);
  private:
  ::goby::middleware::frontseat::protobuf::HelmState _internal_state() const;
  void _internal_set_state(::goby::middleware::frontseat::protobuf::HelmState value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.HelmStateReport)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int state_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// -------------------------------------------------------------------
 
class InterfaceStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.InterfaceStatus) */ {
 public:
  inline InterfaceStatus() : InterfaceStatus(nullptr) {}
  ~InterfaceStatus() override;
  explicit PROTOBUF_CONSTEXPR InterfaceStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  InterfaceStatus(const InterfaceStatus& from);
  InterfaceStatus(InterfaceStatus&& from) noexcept
    : InterfaceStatus() {
    *this = ::std::move(from);
  }
 
  inline InterfaceStatus& operator=(const InterfaceStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline InterfaceStatus& operator=(InterfaceStatus&& 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 InterfaceStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const InterfaceStatus* internal_default_instance() {
    return reinterpret_cast<const InterfaceStatus*>(
               &_InterfaceStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(InterfaceStatus& a, InterfaceStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(InterfaceStatus* 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(InterfaceStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  InterfaceStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InterfaceStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InterfaceStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InterfaceStatus& from) {
    InterfaceStatus::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(InterfaceStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.InterfaceStatus";
  }
  protected:
  explicit InterfaceStatus(::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 {
    kFrontseatStateFieldNumber = 2,
    kHelmStateFieldNumber = 3,
    kHelmErrorFieldNumber = 4,
    kFrontseatErrorFieldNumber = 5,
    kFrontseatProvidingDataFieldNumber = 6,
    kStateFieldNumber = 1,
  };
  // optional .goby.middleware.frontseat.protobuf.FrontSeatState frontseat_state = 2;
  bool has_frontseat_state() const;
  private:
  bool _internal_has_frontseat_state() const;
  public:
  void clear_frontseat_state();
  ::goby::middleware::frontseat::protobuf::FrontSeatState frontseat_state() const;
  void set_frontseat_state(::goby::middleware::frontseat::protobuf::FrontSeatState value);
  private:
  ::goby::middleware::frontseat::protobuf::FrontSeatState _internal_frontseat_state() const;
  void _internal_set_frontseat_state(::goby::middleware::frontseat::protobuf::FrontSeatState value);
  public:
 
  // optional .goby.middleware.frontseat.protobuf.HelmState helm_state = 3;
  bool has_helm_state() const;
  private:
  bool _internal_has_helm_state() const;
  public:
  void clear_helm_state();
  ::goby::middleware::frontseat::protobuf::HelmState helm_state() const;
  void set_helm_state(::goby::middleware::frontseat::protobuf::HelmState value);
  private:
  ::goby::middleware::frontseat::protobuf::HelmState _internal_helm_state() const;
  void _internal_set_helm_state(::goby::middleware::frontseat::protobuf::HelmState value);
  public:
 
  // optional .goby.middleware.frontseat.protobuf.HelmError helm_error = 4;
  bool has_helm_error() const;
  private:
  bool _internal_has_helm_error() const;
  public:
  void clear_helm_error();
  ::goby::middleware::frontseat::protobuf::HelmError helm_error() const;
  void set_helm_error(::goby::middleware::frontseat::protobuf::HelmError value);
  private:
  ::goby::middleware::frontseat::protobuf::HelmError _internal_helm_error() const;
  void _internal_set_helm_error(::goby::middleware::frontseat::protobuf::HelmError value);
  public:
 
  // optional .goby.middleware.frontseat.protobuf.FrontSeatError frontseat_error = 5;
  bool has_frontseat_error() const;
  private:
  bool _internal_has_frontseat_error() const;
  public:
  void clear_frontseat_error();
  ::goby::middleware::frontseat::protobuf::FrontSeatError frontseat_error() const;
  void set_frontseat_error(::goby::middleware::frontseat::protobuf::FrontSeatError value);
  private:
  ::goby::middleware::frontseat::protobuf::FrontSeatError _internal_frontseat_error() const;
  void _internal_set_frontseat_error(::goby::middleware::frontseat::protobuf::FrontSeatError value);
  public:
 
  // optional bool frontseat_providing_data = 6;
  bool has_frontseat_providing_data() const;
  private:
  bool _internal_has_frontseat_providing_data() const;
  public:
  void clear_frontseat_providing_data();
  bool frontseat_providing_data() const;
  void set_frontseat_providing_data(bool value);
  private:
  bool _internal_frontseat_providing_data() const;
  void _internal_set_frontseat_providing_data(bool value);
  public:
 
  // optional .goby.middleware.frontseat.protobuf.InterfaceState state = 1;
  bool has_state() const;
  private:
  bool _internal_has_state() const;
  public:
  void clear_state();
  ::goby::middleware::frontseat::protobuf::InterfaceState state() const;
  void set_state(::goby::middleware::frontseat::protobuf::InterfaceState value);
  private:
  ::goby::middleware::frontseat::protobuf::InterfaceState _internal_state() const;
  void _internal_set_state(::goby::middleware::frontseat::protobuf::InterfaceState value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.InterfaceStatus)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int frontseat_state_;
    int helm_state_;
    int helm_error_;
    int frontseat_error_;
    bool frontseat_providing_data_;
    int state_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// -------------------------------------------------------------------
 
class CommandRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.CommandRequest) */ {
 public:
  inline CommandRequest() : CommandRequest(nullptr) {}
  ~CommandRequest() override;
  explicit PROTOBUF_CONSTEXPR CommandRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  CommandRequest(const CommandRequest& from);
  CommandRequest(CommandRequest&& from) noexcept
    : CommandRequest() {
    *this = ::std::move(from);
  }
 
  inline CommandRequest& operator=(const CommandRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommandRequest& operator=(CommandRequest&& 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 CommandRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CommandRequest* internal_default_instance() {
    return reinterpret_cast<const CommandRequest*>(
               &_CommandRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(CommandRequest& a, CommandRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CommandRequest* 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(CommandRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  CommandRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommandRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CommandRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CommandRequest& from) {
    CommandRequest::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(CommandRequest* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.CommandRequest";
  }
  protected:
  explicit CommandRequest(::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 {
    kDesiredCourseFieldNumber = 1,
    kResponseRequestedFieldNumber = 10,
    kRequestIdFieldNumber = 11,
    kCancelRequestIdFieldNumber = 20,
  };
  // optional .goby.middleware.frontseat.protobuf.DesiredCourse desired_course = 1;
  bool has_desired_course() const;
  private:
  bool _internal_has_desired_course() const;
  public:
  void clear_desired_course();
  const ::goby::middleware::frontseat::protobuf::DesiredCourse& desired_course() const;
  PROTOBUF_NODISCARD ::goby::middleware::frontseat::protobuf::DesiredCourse* release_desired_course();
  ::goby::middleware::frontseat::protobuf::DesiredCourse* mutable_desired_course();
  void set_allocated_desired_course(::goby::middleware::frontseat::protobuf::DesiredCourse* desired_course);
  private:
  const ::goby::middleware::frontseat::protobuf::DesiredCourse& _internal_desired_course() const;
  ::goby::middleware::frontseat::protobuf::DesiredCourse* _internal_mutable_desired_course();
  public:
  void unsafe_arena_set_allocated_desired_course(
      ::goby::middleware::frontseat::protobuf::DesiredCourse* desired_course);
  ::goby::middleware::frontseat::protobuf::DesiredCourse* unsafe_arena_release_desired_course();
 
  // optional bool response_requested = 10 [default = false];
  bool has_response_requested() const;
  private:
  bool _internal_has_response_requested() const;
  public:
  void clear_response_requested();
  bool response_requested() const;
  void set_response_requested(bool value);
  private:
  bool _internal_response_requested() const;
  void _internal_set_response_requested(bool value);
  public:
 
  // optional int32 request_id = 11;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  int32_t request_id() const;
  void set_request_id(int32_t value);
  private:
  int32_t _internal_request_id() const;
  void _internal_set_request_id(int32_t value);
  public:
 
  // optional int32 cancel_request_id = 20;
  bool has_cancel_request_id() const;
  private:
  bool _internal_has_cancel_request_id() const;
  public:
  void clear_cancel_request_id();
  int32_t cancel_request_id() const;
  void set_cancel_request_id(int32_t value);
  private:
  int32_t _internal_cancel_request_id() const;
  void _internal_set_cancel_request_id(int32_t value);
  public:
 
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.Has(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.ExtensionSize(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {
 
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
 
    return to_add;
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandRequest, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.CommandRequest)
 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::ExtensionSet _extensions_;
 
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::goby::middleware::frontseat::protobuf::DesiredCourse* desired_course_;
    bool response_requested_;
    int32_t request_id_;
    int32_t cancel_request_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// -------------------------------------------------------------------
 
class CommandResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.CommandResponse) */ {
 public:
  inline CommandResponse() : CommandResponse(nullptr) {}
  ~CommandResponse() override;
  explicit PROTOBUF_CONSTEXPR CommandResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  CommandResponse(const CommandResponse& from);
  CommandResponse(CommandResponse&& from) noexcept
    : CommandResponse() {
    *this = ::std::move(from);
  }
 
  inline CommandResponse& operator=(const CommandResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CommandResponse& operator=(CommandResponse&& 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 CommandResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CommandResponse* internal_default_instance() {
    return reinterpret_cast<const CommandResponse*>(
               &_CommandResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(CommandResponse& a, CommandResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CommandResponse* 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(CommandResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  CommandResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CommandResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CommandResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CommandResponse& from) {
    CommandResponse::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(CommandResponse* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.CommandResponse";
  }
  protected:
  explicit CommandResponse(::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 {
    kErrorStringFieldNumber = 21,
    kRequestSuccessfulFieldNumber = 10,
    kRequestIdFieldNumber = 11,
    kErrorCodeFieldNumber = 20,
  };
  // optional string error_string = 21;
  bool has_error_string() const;
  private:
  bool _internal_has_error_string() const;
  public:
  void clear_error_string();
  const std::string& error_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_error_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_error_string();
  PROTOBUF_NODISCARD std::string* release_error_string();
  void set_allocated_error_string(std::string* error_string);
  private:
  const std::string& _internal_error_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_string(const std::string& value);
  std::string* _internal_mutable_error_string();
  public:
 
  // optional bool request_successful = 10;
  bool has_request_successful() const;
  private:
  bool _internal_has_request_successful() const;
  public:
  void clear_request_successful();
  bool request_successful() const;
  void set_request_successful(bool value);
  private:
  bool _internal_request_successful() const;
  void _internal_set_request_successful(bool value);
  public:
 
  // optional int32 request_id = 11;
  bool has_request_id() const;
  private:
  bool _internal_has_request_id() const;
  public:
  void clear_request_id();
  int32_t request_id() const;
  void set_request_id(int32_t value);
  private:
  int32_t _internal_request_id() const;
  void _internal_set_request_id(int32_t value);
  public:
 
  // optional int32 error_code = 20 [default = 0];
  bool has_error_code() const;
  private:
  bool _internal_has_error_code() const;
  public:
  void clear_error_code();
  int32_t error_code() const;
  void set_error_code(int32_t value);
  private:
  int32_t _internal_error_code() const;
  void _internal_set_error_code(int32_t value);
  public:
 
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.Has(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.ExtensionSize(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {
 
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
 
    return to_add;
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          CommandResponse, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.CommandResponse)
 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::ExtensionSet _extensions_;
 
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_string_;
    bool request_successful_;
    int32_t request_id_;
    int32_t error_code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// -------------------------------------------------------------------
 
class InterfaceData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.InterfaceData) */ {
 public:
  inline InterfaceData() : InterfaceData(nullptr) {}
  ~InterfaceData() override;
  explicit PROTOBUF_CONSTEXPR InterfaceData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  InterfaceData(const InterfaceData& from);
  InterfaceData(InterfaceData&& from) noexcept
    : InterfaceData() {
    *this = ::std::move(from);
  }
 
  inline InterfaceData& operator=(const InterfaceData& from) {
    CopyFrom(from);
    return *this;
  }
  inline InterfaceData& operator=(InterfaceData&& 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 InterfaceData& default_instance() {
    return *internal_default_instance();
  }
  static inline const InterfaceData* internal_default_instance() {
    return reinterpret_cast<const InterfaceData*>(
               &_InterfaceData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(InterfaceData& a, InterfaceData& b) {
    a.Swap(&b);
  }
  inline void Swap(InterfaceData* 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(InterfaceData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  InterfaceData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InterfaceData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InterfaceData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InterfaceData& from) {
    InterfaceData::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(InterfaceData* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.InterfaceData";
  }
  protected:
  explicit InterfaceData(::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 {
    kDcclMessageFieldNumber = 3,
    kNodeStatusFieldNumber = 1,
    kCtdSampleFieldNumber = 2,
  };
  // optional bytes dccl_message = 3;
  bool has_dccl_message() const;
  private:
  bool _internal_has_dccl_message() const;
  public:
  void clear_dccl_message();
  const std::string& dccl_message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dccl_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dccl_message();
  PROTOBUF_NODISCARD std::string* release_dccl_message();
  void set_allocated_dccl_message(std::string* dccl_message);
  private:
  const std::string& _internal_dccl_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dccl_message(const std::string& value);
  std::string* _internal_mutable_dccl_message();
  public:
 
  // optional .goby.middleware.frontseat.protobuf.NodeStatus node_status = 1;
  bool has_node_status() const;
  private:
  bool _internal_has_node_status() const;
  public:
  void clear_node_status();
  const ::goby::middleware::frontseat::protobuf::NodeStatus& node_status() const;
  PROTOBUF_NODISCARD ::goby::middleware::frontseat::protobuf::NodeStatus* release_node_status();
  ::goby::middleware::frontseat::protobuf::NodeStatus* mutable_node_status();
  void set_allocated_node_status(::goby::middleware::frontseat::protobuf::NodeStatus* node_status);
  private:
  const ::goby::middleware::frontseat::protobuf::NodeStatus& _internal_node_status() const;
  ::goby::middleware::frontseat::protobuf::NodeStatus* _internal_mutable_node_status();
  public:
  void unsafe_arena_set_allocated_node_status(
      ::goby::middleware::frontseat::protobuf::NodeStatus* node_status);
  ::goby::middleware::frontseat::protobuf::NodeStatus* unsafe_arena_release_node_status();
 
  // optional .goby.middleware.frontseat.protobuf.CTDSample ctd_sample = 2;
  bool has_ctd_sample() const;
  private:
  bool _internal_has_ctd_sample() const;
  public:
  void clear_ctd_sample();
  const ::goby::middleware::frontseat::protobuf::CTDSample& ctd_sample() const;
  PROTOBUF_NODISCARD ::goby::middleware::frontseat::protobuf::CTDSample* release_ctd_sample();
  ::goby::middleware::frontseat::protobuf::CTDSample* mutable_ctd_sample();
  void set_allocated_ctd_sample(::goby::middleware::frontseat::protobuf::CTDSample* ctd_sample);
  private:
  const ::goby::middleware::frontseat::protobuf::CTDSample& _internal_ctd_sample() const;
  ::goby::middleware::frontseat::protobuf::CTDSample* _internal_mutable_ctd_sample();
  public:
  void unsafe_arena_set_allocated_ctd_sample(
      ::goby::middleware::frontseat::protobuf::CTDSample* ctd_sample);
  ::goby::middleware::frontseat::protobuf::CTDSample* unsafe_arena_release_ctd_sample();
 
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.Has(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.ExtensionSize(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {
 
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
 
    return to_add;
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          InterfaceData, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.InterfaceData)
 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::ExtensionSet _extensions_;
 
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dccl_message_;
    ::goby::middleware::frontseat::protobuf::NodeStatus* node_status_;
    ::goby::middleware::frontseat::protobuf::CTDSample* ctd_sample_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// -------------------------------------------------------------------
 
class Raw final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.frontseat.protobuf.Raw) */ {
 public:
  inline Raw() : Raw(nullptr) {}
  ~Raw() override;
  explicit PROTOBUF_CONSTEXPR Raw(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Raw(const Raw& from);
  Raw(Raw&& from) noexcept
    : Raw() {
    *this = ::std::move(from);
  }
 
  inline Raw& operator=(const Raw& from) {
    CopyFrom(from);
    return *this;
  }
  inline Raw& operator=(Raw&& 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 Raw& default_instance() {
    return *internal_default_instance();
  }
  static inline const Raw* internal_default_instance() {
    return reinterpret_cast<const Raw*>(
               &_Raw_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(Raw& a, Raw& b) {
    a.Swap(&b);
  }
  inline void Swap(Raw* 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(Raw* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Raw* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Raw>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Raw& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Raw& from) {
    Raw::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(Raw* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.frontseat.protobuf.Raw";
  }
  protected:
  explicit Raw(::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 Raw_RawType RawType;
  static constexpr RawType RAW_ASCII =
    Raw_RawType_RAW_ASCII;
  static constexpr RawType RAW_BINARY =
    Raw_RawType_RAW_BINARY;
  static inline bool RawType_IsValid(int value) {
    return Raw_RawType_IsValid(value);
  }
  static constexpr RawType RawType_MIN =
    Raw_RawType_RawType_MIN;
  static constexpr RawType RawType_MAX =
    Raw_RawType_RawType_MAX;
  static constexpr int RawType_ARRAYSIZE =
    Raw_RawType_RawType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RawType_descriptor() {
    return Raw_RawType_descriptor();
  }
  template<typename T>
  static inline const std::string& RawType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RawType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RawType_Name.");
    return Raw_RawType_Name(enum_t_value);
  }
  static inline bool RawType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RawType* value) {
    return Raw_RawType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRawFieldNumber = 1,
    kDescriptionFieldNumber = 3,
    kTypeFieldNumber = 2,
  };
  // optional bytes raw = 1;
  bool has_raw() const;
  private:
  bool _internal_has_raw() const;
  public:
  void clear_raw();
  const std::string& raw() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_raw(ArgT0&& arg0, ArgT... args);
  std::string* mutable_raw();
  PROTOBUF_NODISCARD std::string* release_raw();
  void set_allocated_raw(std::string* raw);
  private:
  const std::string& _internal_raw() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw(const std::string& value);
  std::string* _internal_mutable_raw();
  public:
 
  // optional string description = 3;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:
 
  // optional .goby.middleware.frontseat.protobuf.Raw.RawType type = 2 [default = RAW_ASCII];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::goby::middleware::frontseat::protobuf::Raw_RawType type() const;
  void set_type(::goby::middleware::frontseat::protobuf::Raw_RawType value);
  private:
  ::goby::middleware::frontseat::protobuf::Raw_RawType _internal_type() const;
  void _internal_set_type(::goby::middleware::frontseat::protobuf::Raw_RawType value);
  public:
 
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline bool HasExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.Has(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline int ExtensionSize(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _impl_._extensions_.ExtensionSize(id.number());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
                                  id.default_value());
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Mutable(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
                                    &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
                                               value, &_impl_._extensions_);
 
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_NODISCARD inline
      typename _proto_TypeTraits::Singular::MutableType
      ReleaseExtension(
          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
              Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::Release(id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
                                                 &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) const {
 
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index) {
 
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
 
    return to_add;
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
                           &_impl_._extensions_);
 
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
  GetRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) const {
 
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }
 
  template <typename _proto_TypeTraits,
            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
  MutableRepeatedExtension(
      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
          Raw, _proto_TypeTraits, _field_type, _is_packed>& id) {
 
    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
                                              _is_packed, &_impl_._extensions_);
  }
 
  // @@protoc_insertion_point(class_scope:goby.middleware.frontseat.protobuf.Raw)
 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::ExtensionSet _extensions_;
 
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// HelmStateReport
 
// required .goby.middleware.frontseat.protobuf.HelmState state = 1;
inline bool HelmStateReport::_internal_has_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HelmStateReport::has_state() const {
  return _internal_has_state();
}
inline void HelmStateReport::clear_state() {
  _impl_.state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::goby::middleware::frontseat::protobuf::HelmState HelmStateReport::_internal_state() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::HelmState >(_impl_.state_);
}
inline ::goby::middleware::frontseat::protobuf::HelmState HelmStateReport::state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.HelmStateReport.state)
  return _internal_state();
}
inline void HelmStateReport::_internal_set_state(::goby::middleware::frontseat::protobuf::HelmState value) {
  assert(::goby::middleware::frontseat::protobuf::HelmState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.state_ = value;
}
inline void HelmStateReport::set_state(::goby::middleware::frontseat::protobuf::HelmState value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.HelmStateReport.state)
}
 
// -------------------------------------------------------------------
 
// InterfaceStatus
 
// optional .goby.middleware.frontseat.protobuf.InterfaceState state = 1;
inline bool InterfaceStatus::_internal_has_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool InterfaceStatus::has_state() const {
  return _internal_has_state();
}
inline void InterfaceStatus::clear_state() {
  _impl_.state_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::goby::middleware::frontseat::protobuf::InterfaceState InterfaceStatus::_internal_state() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::InterfaceState >(_impl_.state_);
}
inline ::goby::middleware::frontseat::protobuf::InterfaceState InterfaceStatus::state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.state)
  return _internal_state();
}
inline void InterfaceStatus::_internal_set_state(::goby::middleware::frontseat::protobuf::InterfaceState value) {
  assert(::goby::middleware::frontseat::protobuf::InterfaceState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.state_ = value;
}
inline void InterfaceStatus::set_state(::goby::middleware::frontseat::protobuf::InterfaceState value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.state)
}
 
// optional .goby.middleware.frontseat.protobuf.FrontSeatState frontseat_state = 2;
inline bool InterfaceStatus::_internal_has_frontseat_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool InterfaceStatus::has_frontseat_state() const {
  return _internal_has_frontseat_state();
}
inline void InterfaceStatus::clear_frontseat_state() {
  _impl_.frontseat_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::goby::middleware::frontseat::protobuf::FrontSeatState InterfaceStatus::_internal_frontseat_state() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::FrontSeatState >(_impl_.frontseat_state_);
}
inline ::goby::middleware::frontseat::protobuf::FrontSeatState InterfaceStatus::frontseat_state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_state)
  return _internal_frontseat_state();
}
inline void InterfaceStatus::_internal_set_frontseat_state(::goby::middleware::frontseat::protobuf::FrontSeatState value) {
  assert(::goby::middleware::frontseat::protobuf::FrontSeatState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.frontseat_state_ = value;
}
inline void InterfaceStatus::set_frontseat_state(::goby::middleware::frontseat::protobuf::FrontSeatState value) {
  _internal_set_frontseat_state(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_state)
}
 
// optional .goby.middleware.frontseat.protobuf.HelmState helm_state = 3;
inline bool InterfaceStatus::_internal_has_helm_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool InterfaceStatus::has_helm_state() const {
  return _internal_has_helm_state();
}
inline void InterfaceStatus::clear_helm_state() {
  _impl_.helm_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::middleware::frontseat::protobuf::HelmState InterfaceStatus::_internal_helm_state() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::HelmState >(_impl_.helm_state_);
}
inline ::goby::middleware::frontseat::protobuf::HelmState InterfaceStatus::helm_state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.helm_state)
  return _internal_helm_state();
}
inline void InterfaceStatus::_internal_set_helm_state(::goby::middleware::frontseat::protobuf::HelmState value) {
  assert(::goby::middleware::frontseat::protobuf::HelmState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.helm_state_ = value;
}
inline void InterfaceStatus::set_helm_state(::goby::middleware::frontseat::protobuf::HelmState value) {
  _internal_set_helm_state(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.helm_state)
}
 
// optional .goby.middleware.frontseat.protobuf.HelmError helm_error = 4;
inline bool InterfaceStatus::_internal_has_helm_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool InterfaceStatus::has_helm_error() const {
  return _internal_has_helm_error();
}
inline void InterfaceStatus::clear_helm_error() {
  _impl_.helm_error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::middleware::frontseat::protobuf::HelmError InterfaceStatus::_internal_helm_error() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::HelmError >(_impl_.helm_error_);
}
inline ::goby::middleware::frontseat::protobuf::HelmError InterfaceStatus::helm_error() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.helm_error)
  return _internal_helm_error();
}
inline void InterfaceStatus::_internal_set_helm_error(::goby::middleware::frontseat::protobuf::HelmError value) {
  assert(::goby::middleware::frontseat::protobuf::HelmError_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.helm_error_ = value;
}
inline void InterfaceStatus::set_helm_error(::goby::middleware::frontseat::protobuf::HelmError value) {
  _internal_set_helm_error(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.helm_error)
}
 
// optional .goby.middleware.frontseat.protobuf.FrontSeatError frontseat_error = 5;
inline bool InterfaceStatus::_internal_has_frontseat_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool InterfaceStatus::has_frontseat_error() const {
  return _internal_has_frontseat_error();
}
inline void InterfaceStatus::clear_frontseat_error() {
  _impl_.frontseat_error_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::goby::middleware::frontseat::protobuf::FrontSeatError InterfaceStatus::_internal_frontseat_error() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::FrontSeatError >(_impl_.frontseat_error_);
}
inline ::goby::middleware::frontseat::protobuf::FrontSeatError InterfaceStatus::frontseat_error() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_error)
  return _internal_frontseat_error();
}
inline void InterfaceStatus::_internal_set_frontseat_error(::goby::middleware::frontseat::protobuf::FrontSeatError value) {
  assert(::goby::middleware::frontseat::protobuf::FrontSeatError_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.frontseat_error_ = value;
}
inline void InterfaceStatus::set_frontseat_error(::goby::middleware::frontseat::protobuf::FrontSeatError value) {
  _internal_set_frontseat_error(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_error)
}
 
// optional bool frontseat_providing_data = 6;
inline bool InterfaceStatus::_internal_has_frontseat_providing_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool InterfaceStatus::has_frontseat_providing_data() const {
  return _internal_has_frontseat_providing_data();
}
inline void InterfaceStatus::clear_frontseat_providing_data() {
  _impl_.frontseat_providing_data_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool InterfaceStatus::_internal_frontseat_providing_data() const {
  return _impl_.frontseat_providing_data_;
}
inline bool InterfaceStatus::frontseat_providing_data() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_providing_data)
  return _internal_frontseat_providing_data();
}
inline void InterfaceStatus::_internal_set_frontseat_providing_data(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.frontseat_providing_data_ = value;
}
inline void InterfaceStatus::set_frontseat_providing_data(bool value) {
  _internal_set_frontseat_providing_data(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceStatus.frontseat_providing_data)
}
 
// -------------------------------------------------------------------
 
// CommandRequest
 
// optional .goby.middleware.frontseat.protobuf.DesiredCourse desired_course = 1;
inline bool CommandRequest::_internal_has_desired_course() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.desired_course_ != nullptr);
  return value;
}
inline bool CommandRequest::has_desired_course() const {
  return _internal_has_desired_course();
}
inline const ::goby::middleware::frontseat::protobuf::DesiredCourse& CommandRequest::_internal_desired_course() const {
  const ::goby::middleware::frontseat::protobuf::DesiredCourse* p = _impl_.desired_course_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::frontseat::protobuf::DesiredCourse&>(
      ::goby::middleware::frontseat::protobuf::_DesiredCourse_default_instance_);
}
inline const ::goby::middleware::frontseat::protobuf::DesiredCourse& CommandRequest::desired_course() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandRequest.desired_course)
  return _internal_desired_course();
}
inline void CommandRequest::unsafe_arena_set_allocated_desired_course(
    ::goby::middleware::frontseat::protobuf::DesiredCourse* desired_course) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.desired_course_);
  }
  _impl_.desired_course_ = desired_course;
  if (desired_course) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.frontseat.protobuf.CommandRequest.desired_course)
}
inline ::goby::middleware::frontseat::protobuf::DesiredCourse* CommandRequest::release_desired_course() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::frontseat::protobuf::DesiredCourse* temp = _impl_.desired_course_;
  _impl_.desired_course_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::DesiredCourse* CommandRequest::unsafe_arena_release_desired_course() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.CommandRequest.desired_course)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::frontseat::protobuf::DesiredCourse* temp = _impl_.desired_course_;
  _impl_.desired_course_ = nullptr;
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::DesiredCourse* CommandRequest::_internal_mutable_desired_course() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.desired_course_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::frontseat::protobuf::DesiredCourse>(GetArenaForAllocation());
    _impl_.desired_course_ = p;
  }
  return _impl_.desired_course_;
}
inline ::goby::middleware::frontseat::protobuf::DesiredCourse* CommandRequest::mutable_desired_course() {
  ::goby::middleware::frontseat::protobuf::DesiredCourse* _msg = _internal_mutable_desired_course();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.CommandRequest.desired_course)
  return _msg;
}
inline void CommandRequest::set_allocated_desired_course(::goby::middleware::frontseat::protobuf::DesiredCourse* desired_course) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.desired_course_);
  }
  if (desired_course) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(desired_course));
    if (message_arena != submessage_arena) {
      desired_course = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, desired_course, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.desired_course_ = desired_course;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.CommandRequest.desired_course)
}
 
// optional bool response_requested = 10 [default = false];
inline bool CommandRequest::_internal_has_response_requested() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CommandRequest::has_response_requested() const {
  return _internal_has_response_requested();
}
inline void CommandRequest::clear_response_requested() {
  _impl_.response_requested_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CommandRequest::_internal_response_requested() const {
  return _impl_.response_requested_;
}
inline bool CommandRequest::response_requested() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandRequest.response_requested)
  return _internal_response_requested();
}
inline void CommandRequest::_internal_set_response_requested(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.response_requested_ = value;
}
inline void CommandRequest::set_response_requested(bool value) {
  _internal_set_response_requested(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandRequest.response_requested)
}
 
// optional int32 request_id = 11;
inline bool CommandRequest::_internal_has_request_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CommandRequest::has_request_id() const {
  return _internal_has_request_id();
}
inline void CommandRequest::clear_request_id() {
  _impl_.request_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CommandRequest::_internal_request_id() const {
  return _impl_.request_id_;
}
inline int32_t CommandRequest::request_id() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandRequest.request_id)
  return _internal_request_id();
}
inline void CommandRequest::_internal_set_request_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.request_id_ = value;
}
inline void CommandRequest::set_request_id(int32_t value) {
  _internal_set_request_id(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandRequest.request_id)
}
 
// optional int32 cancel_request_id = 20;
inline bool CommandRequest::_internal_has_cancel_request_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CommandRequest::has_cancel_request_id() const {
  return _internal_has_cancel_request_id();
}
inline void CommandRequest::clear_cancel_request_id() {
  _impl_.cancel_request_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CommandRequest::_internal_cancel_request_id() const {
  return _impl_.cancel_request_id_;
}
inline int32_t CommandRequest::cancel_request_id() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandRequest.cancel_request_id)
  return _internal_cancel_request_id();
}
inline void CommandRequest::_internal_set_cancel_request_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.cancel_request_id_ = value;
}
inline void CommandRequest::set_cancel_request_id(int32_t value) {
  _internal_set_cancel_request_id(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandRequest.cancel_request_id)
}
 
// -------------------------------------------------------------------
 
// CommandResponse
 
// optional bool request_successful = 10;
inline bool CommandResponse::_internal_has_request_successful() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CommandResponse::has_request_successful() const {
  return _internal_has_request_successful();
}
inline void CommandResponse::clear_request_successful() {
  _impl_.request_successful_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CommandResponse::_internal_request_successful() const {
  return _impl_.request_successful_;
}
inline bool CommandResponse::request_successful() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandResponse.request_successful)
  return _internal_request_successful();
}
inline void CommandResponse::_internal_set_request_successful(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.request_successful_ = value;
}
inline void CommandResponse::set_request_successful(bool value) {
  _internal_set_request_successful(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandResponse.request_successful)
}
 
// optional int32 request_id = 11;
inline bool CommandResponse::_internal_has_request_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CommandResponse::has_request_id() const {
  return _internal_has_request_id();
}
inline void CommandResponse::clear_request_id() {
  _impl_.request_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CommandResponse::_internal_request_id() const {
  return _impl_.request_id_;
}
inline int32_t CommandResponse::request_id() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandResponse.request_id)
  return _internal_request_id();
}
inline void CommandResponse::_internal_set_request_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.request_id_ = value;
}
inline void CommandResponse::set_request_id(int32_t value) {
  _internal_set_request_id(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandResponse.request_id)
}
 
// optional int32 error_code = 20 [default = 0];
inline bool CommandResponse::_internal_has_error_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CommandResponse::has_error_code() const {
  return _internal_has_error_code();
}
inline void CommandResponse::clear_error_code() {
  _impl_.error_code_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CommandResponse::_internal_error_code() const {
  return _impl_.error_code_;
}
inline int32_t CommandResponse::error_code() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandResponse.error_code)
  return _internal_error_code();
}
inline void CommandResponse::_internal_set_error_code(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.error_code_ = value;
}
inline void CommandResponse::set_error_code(int32_t value) {
  _internal_set_error_code(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandResponse.error_code)
}
 
// optional string error_string = 21;
inline bool CommandResponse::_internal_has_error_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CommandResponse::has_error_string() const {
  return _internal_has_error_string();
}
inline void CommandResponse::clear_error_string() {
  _impl_.error_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CommandResponse::error_string() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.CommandResponse.error_string)
  return _internal_error_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CommandResponse::set_error_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.error_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.CommandResponse.error_string)
}
inline std::string* CommandResponse::mutable_error_string() {
  std::string* _s = _internal_mutable_error_string();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.CommandResponse.error_string)
  return _s;
}
inline const std::string& CommandResponse::_internal_error_string() const {
  return _impl_.error_string_.Get();
}
inline void CommandResponse::_internal_set_error_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.error_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CommandResponse::_internal_mutable_error_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.error_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CommandResponse::release_error_string() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.CommandResponse.error_string)
  if (!_internal_has_error_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.error_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_string_.IsDefault()) {
    _impl_.error_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CommandResponse::set_allocated_error_string(std::string* error_string) {
  if (error_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.error_string_.SetAllocated(error_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.error_string_.IsDefault()) {
    _impl_.error_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.CommandResponse.error_string)
}
 
// -------------------------------------------------------------------
 
// InterfaceData
 
// optional .goby.middleware.frontseat.protobuf.NodeStatus node_status = 1;
inline bool InterfaceData::_internal_has_node_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.node_status_ != nullptr);
  return value;
}
inline bool InterfaceData::has_node_status() const {
  return _internal_has_node_status();
}
inline const ::goby::middleware::frontseat::protobuf::NodeStatus& InterfaceData::_internal_node_status() const {
  const ::goby::middleware::frontseat::protobuf::NodeStatus* p = _impl_.node_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::frontseat::protobuf::NodeStatus&>(
      ::goby::middleware::frontseat::protobuf::_NodeStatus_default_instance_);
}
inline const ::goby::middleware::frontseat::protobuf::NodeStatus& InterfaceData::node_status() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceData.node_status)
  return _internal_node_status();
}
inline void InterfaceData::unsafe_arena_set_allocated_node_status(
    ::goby::middleware::frontseat::protobuf::NodeStatus* node_status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_status_);
  }
  _impl_.node_status_ = node_status;
  if (node_status) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.frontseat.protobuf.InterfaceData.node_status)
}
inline ::goby::middleware::frontseat::protobuf::NodeStatus* InterfaceData::release_node_status() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::frontseat::protobuf::NodeStatus* temp = _impl_.node_status_;
  _impl_.node_status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::NodeStatus* InterfaceData::unsafe_arena_release_node_status() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.InterfaceData.node_status)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::frontseat::protobuf::NodeStatus* temp = _impl_.node_status_;
  _impl_.node_status_ = nullptr;
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::NodeStatus* InterfaceData::_internal_mutable_node_status() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.node_status_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::frontseat::protobuf::NodeStatus>(GetArenaForAllocation());
    _impl_.node_status_ = p;
  }
  return _impl_.node_status_;
}
inline ::goby::middleware::frontseat::protobuf::NodeStatus* InterfaceData::mutable_node_status() {
  ::goby::middleware::frontseat::protobuf::NodeStatus* _msg = _internal_mutable_node_status();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.InterfaceData.node_status)
  return _msg;
}
inline void InterfaceData::set_allocated_node_status(::goby::middleware::frontseat::protobuf::NodeStatus* node_status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.node_status_);
  }
  if (node_status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_status));
    if (message_arena != submessage_arena) {
      node_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node_status, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.node_status_ = node_status;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.InterfaceData.node_status)
}
 
// optional .goby.middleware.frontseat.protobuf.CTDSample ctd_sample = 2;
inline bool InterfaceData::_internal_has_ctd_sample() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ctd_sample_ != nullptr);
  return value;
}
inline bool InterfaceData::has_ctd_sample() const {
  return _internal_has_ctd_sample();
}
inline const ::goby::middleware::frontseat::protobuf::CTDSample& InterfaceData::_internal_ctd_sample() const {
  const ::goby::middleware::frontseat::protobuf::CTDSample* p = _impl_.ctd_sample_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::frontseat::protobuf::CTDSample&>(
      ::goby::middleware::frontseat::protobuf::_CTDSample_default_instance_);
}
inline const ::goby::middleware::frontseat::protobuf::CTDSample& InterfaceData::ctd_sample() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceData.ctd_sample)
  return _internal_ctd_sample();
}
inline void InterfaceData::unsafe_arena_set_allocated_ctd_sample(
    ::goby::middleware::frontseat::protobuf::CTDSample* ctd_sample) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ctd_sample_);
  }
  _impl_.ctd_sample_ = ctd_sample;
  if (ctd_sample) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.frontseat.protobuf.InterfaceData.ctd_sample)
}
inline ::goby::middleware::frontseat::protobuf::CTDSample* InterfaceData::release_ctd_sample() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::middleware::frontseat::protobuf::CTDSample* temp = _impl_.ctd_sample_;
  _impl_.ctd_sample_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::CTDSample* InterfaceData::unsafe_arena_release_ctd_sample() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.InterfaceData.ctd_sample)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::goby::middleware::frontseat::protobuf::CTDSample* temp = _impl_.ctd_sample_;
  _impl_.ctd_sample_ = nullptr;
  return temp;
}
inline ::goby::middleware::frontseat::protobuf::CTDSample* InterfaceData::_internal_mutable_ctd_sample() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.ctd_sample_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::frontseat::protobuf::CTDSample>(GetArenaForAllocation());
    _impl_.ctd_sample_ = p;
  }
  return _impl_.ctd_sample_;
}
inline ::goby::middleware::frontseat::protobuf::CTDSample* InterfaceData::mutable_ctd_sample() {
  ::goby::middleware::frontseat::protobuf::CTDSample* _msg = _internal_mutable_ctd_sample();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.InterfaceData.ctd_sample)
  return _msg;
}
inline void InterfaceData::set_allocated_ctd_sample(::goby::middleware::frontseat::protobuf::CTDSample* ctd_sample) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ctd_sample_);
  }
  if (ctd_sample) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ctd_sample));
    if (message_arena != submessage_arena) {
      ctd_sample = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ctd_sample, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.ctd_sample_ = ctd_sample;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.InterfaceData.ctd_sample)
}
 
// optional bytes dccl_message = 3;
inline bool InterfaceData::_internal_has_dccl_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool InterfaceData::has_dccl_message() const {
  return _internal_has_dccl_message();
}
inline void InterfaceData::clear_dccl_message() {
  _impl_.dccl_message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& InterfaceData::dccl_message() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.InterfaceData.dccl_message)
  return _internal_dccl_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void InterfaceData::set_dccl_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.dccl_message_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.InterfaceData.dccl_message)
}
inline std::string* InterfaceData::mutable_dccl_message() {
  std::string* _s = _internal_mutable_dccl_message();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.InterfaceData.dccl_message)
  return _s;
}
inline const std::string& InterfaceData::_internal_dccl_message() const {
  return _impl_.dccl_message_.Get();
}
inline void InterfaceData::_internal_set_dccl_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dccl_message_.Set(value, GetArenaForAllocation());
}
inline std::string* InterfaceData::_internal_mutable_dccl_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.dccl_message_.Mutable(GetArenaForAllocation());
}
inline std::string* InterfaceData::release_dccl_message() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.InterfaceData.dccl_message)
  if (!_internal_has_dccl_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.dccl_message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dccl_message_.IsDefault()) {
    _impl_.dccl_message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void InterfaceData::set_allocated_dccl_message(std::string* dccl_message) {
  if (dccl_message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.dccl_message_.SetAllocated(dccl_message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dccl_message_.IsDefault()) {
    _impl_.dccl_message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.InterfaceData.dccl_message)
}
 
// -------------------------------------------------------------------
 
// Raw
 
// optional bytes raw = 1;
inline bool Raw::_internal_has_raw() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Raw::has_raw() const {
  return _internal_has_raw();
}
inline void Raw::clear_raw() {
  _impl_.raw_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Raw::raw() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.Raw.raw)
  return _internal_raw();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Raw::set_raw(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.raw_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.Raw.raw)
}
inline std::string* Raw::mutable_raw() {
  std::string* _s = _internal_mutable_raw();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.Raw.raw)
  return _s;
}
inline const std::string& Raw::_internal_raw() const {
  return _impl_.raw_.Get();
}
inline void Raw::_internal_set_raw(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.raw_.Set(value, GetArenaForAllocation());
}
inline std::string* Raw::_internal_mutable_raw() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.raw_.Mutable(GetArenaForAllocation());
}
inline std::string* Raw::release_raw() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.Raw.raw)
  if (!_internal_has_raw()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.raw_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.raw_.IsDefault()) {
    _impl_.raw_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Raw::set_allocated_raw(std::string* raw) {
  if (raw != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.raw_.SetAllocated(raw, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.raw_.IsDefault()) {
    _impl_.raw_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.Raw.raw)
}
 
// optional .goby.middleware.frontseat.protobuf.Raw.RawType type = 2 [default = RAW_ASCII];
inline bool Raw::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Raw::has_type() const {
  return _internal_has_type();
}
inline void Raw::clear_type() {
  _impl_.type_ = 1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::middleware::frontseat::protobuf::Raw_RawType Raw::_internal_type() const {
  return static_cast< ::goby::middleware::frontseat::protobuf::Raw_RawType >(_impl_.type_);
}
inline ::goby::middleware::frontseat::protobuf::Raw_RawType Raw::type() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.Raw.type)
  return _internal_type();
}
inline void Raw::_internal_set_type(::goby::middleware::frontseat::protobuf::Raw_RawType value) {
  assert(::goby::middleware::frontseat::protobuf::Raw_RawType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void Raw::set_type(::goby::middleware::frontseat::protobuf::Raw_RawType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.Raw.type)
}
 
// optional string description = 3;
inline bool Raw::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Raw::has_description() const {
  return _internal_has_description();
}
inline void Raw::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Raw::description() const {
  // @@protoc_insertion_point(field_get:goby.middleware.frontseat.protobuf.Raw.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Raw::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.frontseat.protobuf.Raw.description)
}
inline std::string* Raw::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:goby.middleware.frontseat.protobuf.Raw.description)
  return _s;
}
inline const std::string& Raw::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Raw::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Raw::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Raw::release_description() {
  // @@protoc_insertion_point(field_release:goby.middleware.frontseat.protobuf.Raw.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Raw::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.frontseat.protobuf.Raw.description)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace frontseat
}  // namespace middleware
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::Raw_RawType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::Raw_RawType>() {
  return ::goby::middleware::frontseat::protobuf::Raw_RawType_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::InterfaceState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::InterfaceState>() {
  return ::goby::middleware::frontseat::protobuf::InterfaceState_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::FrontSeatState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::FrontSeatState>() {
  return ::goby::middleware::frontseat::protobuf::FrontSeatState_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::HelmState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::HelmState>() {
  return ::goby::middleware::frontseat::protobuf::HelmState_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::HelmError> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::HelmError>() {
  return ::goby::middleware::frontseat::protobuf::HelmError_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::frontseat::protobuf::FrontSeatError> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::frontseat::protobuf::FrontSeatError>() {
  return ::goby::middleware::frontseat::protobuf::FrontSeatError_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2ffrontseat_2eproto