io.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/middleware/protobuf/io.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2fio_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2fio_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 <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_2fio_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_2fio_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
namespace goby {
namespace middleware {
namespace protobuf {
class IOData;
struct IODataDefaultTypeInternal;
extern IODataDefaultTypeInternal _IOData_default_instance_;
class IOError;
struct IOErrorDefaultTypeInternal;
extern IOErrorDefaultTypeInternal _IOError_default_instance_;
class IOStatus;
struct IOStatusDefaultTypeInternal;
extern IOStatusDefaultTypeInternal _IOStatus_default_instance_;
class SerialCommand;
struct SerialCommandDefaultTypeInternal;
extern SerialCommandDefaultTypeInternal _SerialCommand_default_instance_;
class SerialStatus;
struct SerialStatusDefaultTypeInternal;
extern SerialStatusDefaultTypeInternal _SerialStatus_default_instance_;
class TCPClientEvent;
struct TCPClientEventDefaultTypeInternal;
extern TCPClientEventDefaultTypeInternal _TCPClientEvent_default_instance_;
class TCPEndPoint;
struct TCPEndPointDefaultTypeInternal;
extern TCPEndPointDefaultTypeInternal _TCPEndPoint_default_instance_;
class TCPServerEvent;
struct TCPServerEventDefaultTypeInternal;
extern TCPServerEventDefaultTypeInternal _TCPServerEvent_default_instance_;
class UDPEndPoint;
struct UDPEndPointDefaultTypeInternal;
extern UDPEndPointDefaultTypeInternal _UDPEndPoint_default_instance_;
}  // namespace protobuf
}  // namespace middleware
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::middleware::protobuf::IOData* Arena::CreateMaybeMessage<::goby::middleware::protobuf::IOData>(Arena*);
template<> ::goby::middleware::protobuf::IOError* Arena::CreateMaybeMessage<::goby::middleware::protobuf::IOError>(Arena*);
template<> ::goby::middleware::protobuf::IOStatus* Arena::CreateMaybeMessage<::goby::middleware::protobuf::IOStatus>(Arena*);
template<> ::goby::middleware::protobuf::SerialCommand* Arena::CreateMaybeMessage<::goby::middleware::protobuf::SerialCommand>(Arena*);
template<> ::goby::middleware::protobuf::SerialStatus* Arena::CreateMaybeMessage<::goby::middleware::protobuf::SerialStatus>(Arena*);
template<> ::goby::middleware::protobuf::TCPClientEvent* Arena::CreateMaybeMessage<::goby::middleware::protobuf::TCPClientEvent>(Arena*);
template<> ::goby::middleware::protobuf::TCPEndPoint* Arena::CreateMaybeMessage<::goby::middleware::protobuf::TCPEndPoint>(Arena*);
template<> ::goby::middleware::protobuf::TCPServerEvent* Arena::CreateMaybeMessage<::goby::middleware::protobuf::TCPServerEvent>(Arena*);
template<> ::goby::middleware::protobuf::UDPEndPoint* Arena::CreateMaybeMessage<::goby::middleware::protobuf::UDPEndPoint>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace middleware {
namespace protobuf {
 
enum SerialCommand_Command : int {
  SerialCommand_Command_SEND_BREAK = 1,
  SerialCommand_Command_RTS_HIGH = 2,
  SerialCommand_Command_RTS_LOW = 3,
  SerialCommand_Command_DTR_HIGH = 4,
  SerialCommand_Command_DTR_LOW = 5
};
bool SerialCommand_Command_IsValid(int value);
constexpr SerialCommand_Command SerialCommand_Command_Command_MIN = SerialCommand_Command_SEND_BREAK;
constexpr SerialCommand_Command SerialCommand_Command_Command_MAX = SerialCommand_Command_DTR_LOW;
constexpr int SerialCommand_Command_Command_ARRAYSIZE = SerialCommand_Command_Command_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SerialCommand_Command_descriptor();
template<typename T>
inline const std::string& SerialCommand_Command_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SerialCommand_Command>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SerialCommand_Command_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SerialCommand_Command_descriptor(), enum_t_value);
}
inline bool SerialCommand_Command_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SerialCommand_Command* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SerialCommand_Command>(
    SerialCommand_Command_descriptor(), name, value);
}
enum TCPServerEvent_Event : int {
  TCPServerEvent_Event_EVENT_BIND = 0,
  TCPServerEvent_Event_EVENT_CONNECT = 1,
  TCPServerEvent_Event_EVENT_DISCONNECT = 2
};
bool TCPServerEvent_Event_IsValid(int value);
constexpr TCPServerEvent_Event TCPServerEvent_Event_Event_MIN = TCPServerEvent_Event_EVENT_BIND;
constexpr TCPServerEvent_Event TCPServerEvent_Event_Event_MAX = TCPServerEvent_Event_EVENT_DISCONNECT;
constexpr int TCPServerEvent_Event_Event_ARRAYSIZE = TCPServerEvent_Event_Event_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TCPServerEvent_Event_descriptor();
template<typename T>
inline const std::string& TCPServerEvent_Event_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TCPServerEvent_Event>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TCPServerEvent_Event_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TCPServerEvent_Event_descriptor(), enum_t_value);
}
inline bool TCPServerEvent_Event_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TCPServerEvent_Event* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TCPServerEvent_Event>(
    TCPServerEvent_Event_descriptor(), name, value);
}
enum TCPClientEvent_Event : int {
  TCPClientEvent_Event_EVENT_CONNECT = 1,
  TCPClientEvent_Event_EVENT_DISCONNECT = 2
};
bool TCPClientEvent_Event_IsValid(int value);
constexpr TCPClientEvent_Event TCPClientEvent_Event_Event_MIN = TCPClientEvent_Event_EVENT_CONNECT;
constexpr TCPClientEvent_Event TCPClientEvent_Event_Event_MAX = TCPClientEvent_Event_EVENT_DISCONNECT;
constexpr int TCPClientEvent_Event_Event_ARRAYSIZE = TCPClientEvent_Event_Event_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TCPClientEvent_Event_descriptor();
template<typename T>
inline const std::string& TCPClientEvent_Event_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TCPClientEvent_Event>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TCPClientEvent_Event_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TCPClientEvent_Event_descriptor(), enum_t_value);
}
inline bool TCPClientEvent_Event_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TCPClientEvent_Event* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TCPClientEvent_Event>(
    TCPClientEvent_Event_descriptor(), name, value);
}
enum IOError_ErrorCode : int {
  IOError_ErrorCode_IO__INIT_FAILURE = 1,
  IOError_ErrorCode_IO__READ_FAILURE = 2,
  IOError_ErrorCode_IO__WRITE_FAILURE = 3,
  IOError_ErrorCode_IO__DATA_TIMEOUT = 4
};
bool IOError_ErrorCode_IsValid(int value);
constexpr IOError_ErrorCode IOError_ErrorCode_ErrorCode_MIN = IOError_ErrorCode_IO__INIT_FAILURE;
constexpr IOError_ErrorCode IOError_ErrorCode_ErrorCode_MAX = IOError_ErrorCode_IO__DATA_TIMEOUT;
constexpr int IOError_ErrorCode_ErrorCode_ARRAYSIZE = IOError_ErrorCode_ErrorCode_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IOError_ErrorCode_descriptor();
template<typename T>
inline const std::string& IOError_ErrorCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, IOError_ErrorCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function IOError_ErrorCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    IOError_ErrorCode_descriptor(), enum_t_value);
}
inline bool IOError_ErrorCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IOError_ErrorCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IOError_ErrorCode>(
    IOError_ErrorCode_descriptor(), name, value);
}
enum IOState : int {
  IO__STATE_UNKNOWN = -1,
  IO__LINK_OPEN = 1,
  IO__LINK_CLOSED = 2,
  IO__CRITICAL_FAILURE = 3
};
bool IOState_IsValid(int value);
constexpr IOState IOState_MIN = IO__STATE_UNKNOWN;
constexpr IOState IOState_MAX = IO__CRITICAL_FAILURE;
constexpr int IOState_ARRAYSIZE = IOState_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IOState_descriptor();
template<typename T>
inline const std::string& IOState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, IOState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function IOState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    IOState_descriptor(), enum_t_value);
}
inline bool IOState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IOState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IOState>(
    IOState_descriptor(), name, value);
}
// ===================================================================
 
class UDPEndPoint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.UDPEndPoint) */ {
 public:
  inline UDPEndPoint() : UDPEndPoint(nullptr) {}
  ~UDPEndPoint() override;
  explicit PROTOBUF_CONSTEXPR UDPEndPoint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  UDPEndPoint(const UDPEndPoint& from);
  UDPEndPoint(UDPEndPoint&& from) noexcept
    : UDPEndPoint() {
    *this = ::std::move(from);
  }
 
  inline UDPEndPoint& operator=(const UDPEndPoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline UDPEndPoint& operator=(UDPEndPoint&& 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 UDPEndPoint& default_instance() {
    return *internal_default_instance();
  }
  static inline const UDPEndPoint* internal_default_instance() {
    return reinterpret_cast<const UDPEndPoint*>(
               &_UDPEndPoint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(UDPEndPoint& a, UDPEndPoint& b) {
    a.Swap(&b);
  }
  inline void Swap(UDPEndPoint* 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(UDPEndPoint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  UDPEndPoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UDPEndPoint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UDPEndPoint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const UDPEndPoint& from) {
    UDPEndPoint::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(UDPEndPoint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.UDPEndPoint";
  }
  protected:
  explicit UDPEndPoint(::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 {
    kAddrFieldNumber = 1,
    kPortFieldNumber = 2,
  };
  // required string addr = 1;
  bool has_addr() const;
  private:
  bool _internal_has_addr() const;
  public:
  void clear_addr();
  const std::string& addr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_addr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_addr();
  PROTOBUF_NODISCARD std::string* release_addr();
  void set_allocated_addr(std::string* addr);
  private:
  const std::string& _internal_addr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_addr(const std::string& value);
  std::string* _internal_mutable_addr();
  public:
 
  // required uint32 port = 2;
  bool has_port() const;
  private:
  bool _internal_has_port() const;
  public:
  void clear_port();
  uint32_t port() const;
  void set_port(uint32_t value);
  private:
  uint32_t _internal_port() const;
  void _internal_set_port(uint32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.UDPEndPoint)
 private:
  class _Internal;
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr addr_;
    uint32_t port_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class TCPEndPoint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.TCPEndPoint) */ {
 public:
  inline TCPEndPoint() : TCPEndPoint(nullptr) {}
  ~TCPEndPoint() override;
  explicit PROTOBUF_CONSTEXPR TCPEndPoint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  TCPEndPoint(const TCPEndPoint& from);
  TCPEndPoint(TCPEndPoint&& from) noexcept
    : TCPEndPoint() {
    *this = ::std::move(from);
  }
 
  inline TCPEndPoint& operator=(const TCPEndPoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline TCPEndPoint& operator=(TCPEndPoint&& 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 TCPEndPoint& default_instance() {
    return *internal_default_instance();
  }
  static inline const TCPEndPoint* internal_default_instance() {
    return reinterpret_cast<const TCPEndPoint*>(
               &_TCPEndPoint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(TCPEndPoint& a, TCPEndPoint& b) {
    a.Swap(&b);
  }
  inline void Swap(TCPEndPoint* 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(TCPEndPoint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  TCPEndPoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TCPEndPoint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TCPEndPoint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TCPEndPoint& from) {
    TCPEndPoint::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(TCPEndPoint* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.TCPEndPoint";
  }
  protected:
  explicit TCPEndPoint(::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 {
    kAddrFieldNumber = 1,
    kPortFieldNumber = 2,
    kAllClientsFieldNumber = 3,
  };
  // optional string addr = 1;
  bool has_addr() const;
  private:
  bool _internal_has_addr() const;
  public:
  void clear_addr();
  const std::string& addr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_addr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_addr();
  PROTOBUF_NODISCARD std::string* release_addr();
  void set_allocated_addr(std::string* addr);
  private:
  const std::string& _internal_addr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_addr(const std::string& value);
  std::string* _internal_mutable_addr();
  public:
 
  // optional uint32 port = 2;
  bool has_port() const;
  private:
  bool _internal_has_port() const;
  public:
  void clear_port();
  uint32_t port() const;
  void set_port(uint32_t value);
  private:
  uint32_t _internal_port() const;
  void _internal_set_port(uint32_t value);
  public:
 
  // optional bool all_clients = 3 [default = false];
  bool has_all_clients() const;
  private:
  bool _internal_has_all_clients() const;
  public:
  void clear_all_clients();
  bool all_clients() const;
  void set_all_clients(bool value);
  private:
  bool _internal_all_clients() const;
  void _internal_set_all_clients(bool value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.TCPEndPoint)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr addr_;
    uint32_t port_;
    bool all_clients_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class IOData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.IOData) */ {
 public:
  inline IOData() : IOData(nullptr) {}
  ~IOData() override;
  explicit PROTOBUF_CONSTEXPR IOData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IOData(const IOData& from);
  IOData(IOData&& from) noexcept
    : IOData() {
    *this = ::std::move(from);
  }
 
  inline IOData& operator=(const IOData& from) {
    CopyFrom(from);
    return *this;
  }
  inline IOData& operator=(IOData&& 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 IOData& default_instance() {
    return *internal_default_instance();
  }
  enum SrcCase {
    kUdpSrc = 10,
    kTcpSrc = 11,
    SRC_NOT_SET = 0,
  };
 
  enum DestCase {
    kUdpDest = 20,
    kTcpDest = 21,
    DEST_NOT_SET = 0,
  };
 
  static inline const IOData* internal_default_instance() {
    return reinterpret_cast<const IOData*>(
               &_IOData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  friend void swap(IOData& a, IOData& b) {
    a.Swap(&b);
  }
  inline void Swap(IOData* 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(IOData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IOData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IOData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IOData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IOData& from) {
    IOData::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(IOData* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.IOData";
  }
  protected:
  explicit IOData(::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 {
    kDataFieldNumber = 30,
    kIndexFieldNumber = 1,
    kUdpSrcFieldNumber = 10,
    kTcpSrcFieldNumber = 11,
    kUdpDestFieldNumber = 20,
    kTcpDestFieldNumber = 21,
  };
  // optional bytes data = 30;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:
 
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // .goby.middleware.protobuf.UDPEndPoint udp_src = 10;
  bool has_udp_src() const;
  private:
  bool _internal_has_udp_src() const;
  public:
  void clear_udp_src();
  const ::goby::middleware::protobuf::UDPEndPoint& udp_src() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::UDPEndPoint* release_udp_src();
  ::goby::middleware::protobuf::UDPEndPoint* mutable_udp_src();
  void set_allocated_udp_src(::goby::middleware::protobuf::UDPEndPoint* udp_src);
  private:
  const ::goby::middleware::protobuf::UDPEndPoint& _internal_udp_src() const;
  ::goby::middleware::protobuf::UDPEndPoint* _internal_mutable_udp_src();
  public:
  void unsafe_arena_set_allocated_udp_src(
      ::goby::middleware::protobuf::UDPEndPoint* udp_src);
  ::goby::middleware::protobuf::UDPEndPoint* unsafe_arena_release_udp_src();
 
  // .goby.middleware.protobuf.TCPEndPoint tcp_src = 11;
  bool has_tcp_src() const;
  private:
  bool _internal_has_tcp_src() const;
  public:
  void clear_tcp_src();
  const ::goby::middleware::protobuf::TCPEndPoint& tcp_src() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_tcp_src();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_tcp_src();
  void set_allocated_tcp_src(::goby::middleware::protobuf::TCPEndPoint* tcp_src);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_tcp_src() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_tcp_src();
  public:
  void unsafe_arena_set_allocated_tcp_src(
      ::goby::middleware::protobuf::TCPEndPoint* tcp_src);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_tcp_src();
 
  // .goby.middleware.protobuf.UDPEndPoint udp_dest = 20;
  bool has_udp_dest() const;
  private:
  bool _internal_has_udp_dest() const;
  public:
  void clear_udp_dest();
  const ::goby::middleware::protobuf::UDPEndPoint& udp_dest() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::UDPEndPoint* release_udp_dest();
  ::goby::middleware::protobuf::UDPEndPoint* mutable_udp_dest();
  void set_allocated_udp_dest(::goby::middleware::protobuf::UDPEndPoint* udp_dest);
  private:
  const ::goby::middleware::protobuf::UDPEndPoint& _internal_udp_dest() const;
  ::goby::middleware::protobuf::UDPEndPoint* _internal_mutable_udp_dest();
  public:
  void unsafe_arena_set_allocated_udp_dest(
      ::goby::middleware::protobuf::UDPEndPoint* udp_dest);
  ::goby::middleware::protobuf::UDPEndPoint* unsafe_arena_release_udp_dest();
 
  // .goby.middleware.protobuf.TCPEndPoint tcp_dest = 21;
  bool has_tcp_dest() const;
  private:
  bool _internal_has_tcp_dest() const;
  public:
  void clear_tcp_dest();
  const ::goby::middleware::protobuf::TCPEndPoint& tcp_dest() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_tcp_dest();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_tcp_dest();
  void set_allocated_tcp_dest(::goby::middleware::protobuf::TCPEndPoint* tcp_dest);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_tcp_dest() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_tcp_dest();
  public:
  void unsafe_arena_set_allocated_tcp_dest(
      ::goby::middleware::protobuf::TCPEndPoint* tcp_dest);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_tcp_dest();
 
  void clear_src();
  SrcCase src_case() const;
  void clear_dest();
  DestCase dest_case() const;
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.IOData)
 private:
  class _Internal;
  void set_has_udp_src();
  void set_has_tcp_src();
  void set_has_udp_dest();
  void set_has_tcp_dest();
 
  inline bool has_src() const;
  inline void clear_has_src();
 
  inline bool has_dest() const;
  inline void clear_has_dest();
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t index_;
    union SrcUnion {
      constexpr SrcUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::goby::middleware::protobuf::UDPEndPoint* udp_src_;
      ::goby::middleware::protobuf::TCPEndPoint* tcp_src_;
    } src_;
    union DestUnion {
      constexpr DestUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::goby::middleware::protobuf::UDPEndPoint* udp_dest_;
      ::goby::middleware::protobuf::TCPEndPoint* tcp_dest_;
    } dest_;
    uint32_t _oneof_case_[2];
 
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class SerialCommand final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.SerialCommand) */ {
 public:
  inline SerialCommand() : SerialCommand(nullptr) {}
  ~SerialCommand() override;
  explicit PROTOBUF_CONSTEXPR SerialCommand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SerialCommand(const SerialCommand& from);
  SerialCommand(SerialCommand&& from) noexcept
    : SerialCommand() {
    *this = ::std::move(from);
  }
 
  inline SerialCommand& operator=(const SerialCommand& from) {
    CopyFrom(from);
    return *this;
  }
  inline SerialCommand& operator=(SerialCommand&& 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 SerialCommand& default_instance() {
    return *internal_default_instance();
  }
  static inline const SerialCommand* internal_default_instance() {
    return reinterpret_cast<const SerialCommand*>(
               &_SerialCommand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  friend void swap(SerialCommand& a, SerialCommand& b) {
    a.Swap(&b);
  }
  inline void Swap(SerialCommand* 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(SerialCommand* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SerialCommand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SerialCommand>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SerialCommand& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SerialCommand& from) {
    SerialCommand::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(SerialCommand* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.SerialCommand";
  }
  protected:
  explicit SerialCommand(::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 SerialCommand_Command Command;
  static constexpr Command SEND_BREAK =
    SerialCommand_Command_SEND_BREAK;
  static constexpr Command RTS_HIGH =
    SerialCommand_Command_RTS_HIGH;
  static constexpr Command RTS_LOW =
    SerialCommand_Command_RTS_LOW;
  static constexpr Command DTR_HIGH =
    SerialCommand_Command_DTR_HIGH;
  static constexpr Command DTR_LOW =
    SerialCommand_Command_DTR_LOW;
  static inline bool Command_IsValid(int value) {
    return SerialCommand_Command_IsValid(value);
  }
  static constexpr Command Command_MIN =
    SerialCommand_Command_Command_MIN;
  static constexpr Command Command_MAX =
    SerialCommand_Command_Command_MAX;
  static constexpr int Command_ARRAYSIZE =
    SerialCommand_Command_Command_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Command_descriptor() {
    return SerialCommand_Command_descriptor();
  }
  template<typename T>
  static inline const std::string& Command_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Command>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Command_Name.");
    return SerialCommand_Command_Name(enum_t_value);
  }
  static inline bool Command_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Command* value) {
    return SerialCommand_Command_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kIndexFieldNumber = 1,
    kCommandFieldNumber = 2,
  };
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // required .goby.middleware.protobuf.SerialCommand.Command command = 2;
  bool has_command() const;
  private:
  bool _internal_has_command() const;
  public:
  void clear_command();
  ::goby::middleware::protobuf::SerialCommand_Command command() const;
  void set_command(::goby::middleware::protobuf::SerialCommand_Command value);
  private:
  ::goby::middleware::protobuf::SerialCommand_Command _internal_command() const;
  void _internal_set_command(::goby::middleware::protobuf::SerialCommand_Command value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.SerialCommand)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t index_;
    int command_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class SerialStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.SerialStatus) */ {
 public:
  inline SerialStatus() : SerialStatus(nullptr) {}
  ~SerialStatus() override;
  explicit PROTOBUF_CONSTEXPR SerialStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  SerialStatus(const SerialStatus& from);
  SerialStatus(SerialStatus&& from) noexcept
    : SerialStatus() {
    *this = ::std::move(from);
  }
 
  inline SerialStatus& operator=(const SerialStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline SerialStatus& operator=(SerialStatus&& 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 SerialStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const SerialStatus* internal_default_instance() {
    return reinterpret_cast<const SerialStatus*>(
               &_SerialStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;
 
  friend void swap(SerialStatus& a, SerialStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(SerialStatus* 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(SerialStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SerialStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SerialStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SerialStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SerialStatus& from) {
    SerialStatus::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(SerialStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.SerialStatus";
  }
  protected:
  explicit SerialStatus(::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 {
    kRtsFieldNumber = 2,
    kDtrFieldNumber = 3,
    kIndexFieldNumber = 1,
  };
  // optional bool rts = 2;
  bool has_rts() const;
  private:
  bool _internal_has_rts() const;
  public:
  void clear_rts();
  bool rts() const;
  void set_rts(bool value);
  private:
  bool _internal_rts() const;
  void _internal_set_rts(bool value);
  public:
 
  // optional bool dtr = 3;
  bool has_dtr() const;
  private:
  bool _internal_has_dtr() const;
  public:
  void clear_dtr();
  bool dtr() const;
  void set_dtr(bool value);
  private:
  bool _internal_dtr() const;
  void _internal_set_dtr(bool value);
  public:
 
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.SerialStatus)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool rts_;
    bool dtr_;
    int32_t index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class TCPServerEvent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.TCPServerEvent) */ {
 public:
  inline TCPServerEvent() : TCPServerEvent(nullptr) {}
  ~TCPServerEvent() override;
  explicit PROTOBUF_CONSTEXPR TCPServerEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  TCPServerEvent(const TCPServerEvent& from);
  TCPServerEvent(TCPServerEvent&& from) noexcept
    : TCPServerEvent() {
    *this = ::std::move(from);
  }
 
  inline TCPServerEvent& operator=(const TCPServerEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline TCPServerEvent& operator=(TCPServerEvent&& 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 TCPServerEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const TCPServerEvent* internal_default_instance() {
    return reinterpret_cast<const TCPServerEvent*>(
               &_TCPServerEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;
 
  friend void swap(TCPServerEvent& a, TCPServerEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(TCPServerEvent* 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(TCPServerEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  TCPServerEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TCPServerEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TCPServerEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TCPServerEvent& from) {
    TCPServerEvent::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(TCPServerEvent* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.TCPServerEvent";
  }
  protected:
  explicit TCPServerEvent(::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 TCPServerEvent_Event Event;
  static constexpr Event EVENT_BIND =
    TCPServerEvent_Event_EVENT_BIND;
  static constexpr Event EVENT_CONNECT =
    TCPServerEvent_Event_EVENT_CONNECT;
  static constexpr Event EVENT_DISCONNECT =
    TCPServerEvent_Event_EVENT_DISCONNECT;
  static inline bool Event_IsValid(int value) {
    return TCPServerEvent_Event_IsValid(value);
  }
  static constexpr Event Event_MIN =
    TCPServerEvent_Event_Event_MIN;
  static constexpr Event Event_MAX =
    TCPServerEvent_Event_Event_MAX;
  static constexpr int Event_ARRAYSIZE =
    TCPServerEvent_Event_Event_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Event_descriptor() {
    return TCPServerEvent_Event_descriptor();
  }
  template<typename T>
  static inline const std::string& Event_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Event>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Event_Name.");
    return TCPServerEvent_Event_Name(enum_t_value);
  }
  static inline bool Event_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Event* value) {
    return TCPServerEvent_Event_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kLocalEndpointFieldNumber = 3,
    kRemoteEndpointFieldNumber = 4,
    kEventFieldNumber = 2,
    kNumberOfClientsFieldNumber = 5,
    kIndexFieldNumber = 1,
  };
  // optional .goby.middleware.protobuf.TCPEndPoint local_endpoint = 3;
  bool has_local_endpoint() const;
  private:
  bool _internal_has_local_endpoint() const;
  public:
  void clear_local_endpoint();
  const ::goby::middleware::protobuf::TCPEndPoint& local_endpoint() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_local_endpoint();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_local_endpoint();
  void set_allocated_local_endpoint(::goby::middleware::protobuf::TCPEndPoint* local_endpoint);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_local_endpoint() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_local_endpoint();
  public:
  void unsafe_arena_set_allocated_local_endpoint(
      ::goby::middleware::protobuf::TCPEndPoint* local_endpoint);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_local_endpoint();
 
  // optional .goby.middleware.protobuf.TCPEndPoint remote_endpoint = 4;
  bool has_remote_endpoint() const;
  private:
  bool _internal_has_remote_endpoint() const;
  public:
  void clear_remote_endpoint();
  const ::goby::middleware::protobuf::TCPEndPoint& remote_endpoint() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_remote_endpoint();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_remote_endpoint();
  void set_allocated_remote_endpoint(::goby::middleware::protobuf::TCPEndPoint* remote_endpoint);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_remote_endpoint() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_remote_endpoint();
  public:
  void unsafe_arena_set_allocated_remote_endpoint(
      ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_remote_endpoint();
 
  // required .goby.middleware.protobuf.TCPServerEvent.Event event = 2;
  bool has_event() const;
  private:
  bool _internal_has_event() const;
  public:
  void clear_event();
  ::goby::middleware::protobuf::TCPServerEvent_Event event() const;
  void set_event(::goby::middleware::protobuf::TCPServerEvent_Event value);
  private:
  ::goby::middleware::protobuf::TCPServerEvent_Event _internal_event() const;
  void _internal_set_event(::goby::middleware::protobuf::TCPServerEvent_Event value);
  public:
 
  // optional int32 number_of_clients = 5;
  bool has_number_of_clients() const;
  private:
  bool _internal_has_number_of_clients() const;
  public:
  void clear_number_of_clients();
  int32_t number_of_clients() const;
  void set_number_of_clients(int32_t value);
  private:
  int32_t _internal_number_of_clients() const;
  void _internal_set_number_of_clients(int32_t value);
  public:
 
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.TCPServerEvent)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::goby::middleware::protobuf::TCPEndPoint* local_endpoint_;
    ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint_;
    int event_;
    int32_t number_of_clients_;
    int32_t index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class TCPClientEvent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.TCPClientEvent) */ {
 public:
  inline TCPClientEvent() : TCPClientEvent(nullptr) {}
  ~TCPClientEvent() override;
  explicit PROTOBUF_CONSTEXPR TCPClientEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  TCPClientEvent(const TCPClientEvent& from);
  TCPClientEvent(TCPClientEvent&& from) noexcept
    : TCPClientEvent() {
    *this = ::std::move(from);
  }
 
  inline TCPClientEvent& operator=(const TCPClientEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline TCPClientEvent& operator=(TCPClientEvent&& 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 TCPClientEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const TCPClientEvent* internal_default_instance() {
    return reinterpret_cast<const TCPClientEvent*>(
               &_TCPClientEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;
 
  friend void swap(TCPClientEvent& a, TCPClientEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(TCPClientEvent* 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(TCPClientEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  TCPClientEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TCPClientEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TCPClientEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TCPClientEvent& from) {
    TCPClientEvent::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(TCPClientEvent* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.TCPClientEvent";
  }
  protected:
  explicit TCPClientEvent(::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 TCPClientEvent_Event Event;
  static constexpr Event EVENT_CONNECT =
    TCPClientEvent_Event_EVENT_CONNECT;
  static constexpr Event EVENT_DISCONNECT =
    TCPClientEvent_Event_EVENT_DISCONNECT;
  static inline bool Event_IsValid(int value) {
    return TCPClientEvent_Event_IsValid(value);
  }
  static constexpr Event Event_MIN =
    TCPClientEvent_Event_Event_MIN;
  static constexpr Event Event_MAX =
    TCPClientEvent_Event_Event_MAX;
  static constexpr int Event_ARRAYSIZE =
    TCPClientEvent_Event_Event_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Event_descriptor() {
    return TCPClientEvent_Event_descriptor();
  }
  template<typename T>
  static inline const std::string& Event_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Event>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Event_Name.");
    return TCPClientEvent_Event_Name(enum_t_value);
  }
  static inline bool Event_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Event* value) {
    return TCPClientEvent_Event_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kLocalEndpointFieldNumber = 3,
    kRemoteEndpointFieldNumber = 4,
    kIndexFieldNumber = 1,
    kEventFieldNumber = 2,
  };
  // optional .goby.middleware.protobuf.TCPEndPoint local_endpoint = 3;
  bool has_local_endpoint() const;
  private:
  bool _internal_has_local_endpoint() const;
  public:
  void clear_local_endpoint();
  const ::goby::middleware::protobuf::TCPEndPoint& local_endpoint() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_local_endpoint();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_local_endpoint();
  void set_allocated_local_endpoint(::goby::middleware::protobuf::TCPEndPoint* local_endpoint);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_local_endpoint() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_local_endpoint();
  public:
  void unsafe_arena_set_allocated_local_endpoint(
      ::goby::middleware::protobuf::TCPEndPoint* local_endpoint);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_local_endpoint();
 
  // optional .goby.middleware.protobuf.TCPEndPoint remote_endpoint = 4;
  bool has_remote_endpoint() const;
  private:
  bool _internal_has_remote_endpoint() const;
  public:
  void clear_remote_endpoint();
  const ::goby::middleware::protobuf::TCPEndPoint& remote_endpoint() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::TCPEndPoint* release_remote_endpoint();
  ::goby::middleware::protobuf::TCPEndPoint* mutable_remote_endpoint();
  void set_allocated_remote_endpoint(::goby::middleware::protobuf::TCPEndPoint* remote_endpoint);
  private:
  const ::goby::middleware::protobuf::TCPEndPoint& _internal_remote_endpoint() const;
  ::goby::middleware::protobuf::TCPEndPoint* _internal_mutable_remote_endpoint();
  public:
  void unsafe_arena_set_allocated_remote_endpoint(
      ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint);
  ::goby::middleware::protobuf::TCPEndPoint* unsafe_arena_release_remote_endpoint();
 
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // required .goby.middleware.protobuf.TCPClientEvent.Event event = 2;
  bool has_event() const;
  private:
  bool _internal_has_event() const;
  public:
  void clear_event();
  ::goby::middleware::protobuf::TCPClientEvent_Event event() const;
  void set_event(::goby::middleware::protobuf::TCPClientEvent_Event value);
  private:
  ::goby::middleware::protobuf::TCPClientEvent_Event _internal_event() const;
  void _internal_set_event(::goby::middleware::protobuf::TCPClientEvent_Event value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.TCPClientEvent)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::goby::middleware::protobuf::TCPEndPoint* local_endpoint_;
    ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint_;
    int32_t index_;
    int event_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class IOError final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.IOError) */ {
 public:
  inline IOError() : IOError(nullptr) {}
  ~IOError() override;
  explicit PROTOBUF_CONSTEXPR IOError(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IOError(const IOError& from);
  IOError(IOError&& from) noexcept
    : IOError() {
    *this = ::std::move(from);
  }
 
  inline IOError& operator=(const IOError& from) {
    CopyFrom(from);
    return *this;
  }
  inline IOError& operator=(IOError&& 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 IOError& default_instance() {
    return *internal_default_instance();
  }
  static inline const IOError* internal_default_instance() {
    return reinterpret_cast<const IOError*>(
               &_IOError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;
 
  friend void swap(IOError& a, IOError& b) {
    a.Swap(&b);
  }
  inline void Swap(IOError* 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(IOError* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IOError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IOError>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IOError& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IOError& from) {
    IOError::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(IOError* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.IOError";
  }
  protected:
  explicit IOError(::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 IOError_ErrorCode ErrorCode;
  static constexpr ErrorCode IO__INIT_FAILURE =
    IOError_ErrorCode_IO__INIT_FAILURE;
  static constexpr ErrorCode IO__READ_FAILURE =
    IOError_ErrorCode_IO__READ_FAILURE;
  static constexpr ErrorCode IO__WRITE_FAILURE =
    IOError_ErrorCode_IO__WRITE_FAILURE;
  static constexpr ErrorCode IO__DATA_TIMEOUT =
    IOError_ErrorCode_IO__DATA_TIMEOUT;
  static inline bool ErrorCode_IsValid(int value) {
    return IOError_ErrorCode_IsValid(value);
  }
  static constexpr ErrorCode ErrorCode_MIN =
    IOError_ErrorCode_ErrorCode_MIN;
  static constexpr ErrorCode ErrorCode_MAX =
    IOError_ErrorCode_ErrorCode_MAX;
  static constexpr int ErrorCode_ARRAYSIZE =
    IOError_ErrorCode_ErrorCode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ErrorCode_descriptor() {
    return IOError_ErrorCode_descriptor();
  }
  template<typename T>
  static inline const std::string& ErrorCode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ErrorCode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ErrorCode_Name.");
    return IOError_ErrorCode_Name(enum_t_value);
  }
  static inline bool ErrorCode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ErrorCode* value) {
    return IOError_ErrorCode_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kTextFieldNumber = 2,
    kCodeFieldNumber = 1,
  };
  // optional string text = 2;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:
 
  // required .goby.middleware.protobuf.IOError.ErrorCode code = 1;
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  ::goby::middleware::protobuf::IOError_ErrorCode code() const;
  void set_code(::goby::middleware::protobuf::IOError_ErrorCode value);
  private:
  ::goby::middleware::protobuf::IOError_ErrorCode _internal_code() const;
  void _internal_set_code(::goby::middleware::protobuf::IOError_ErrorCode value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.IOError)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
    int code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// -------------------------------------------------------------------
 
class IOStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.IOStatus) */ {
 public:
  inline IOStatus() : IOStatus(nullptr) {}
  ~IOStatus() override;
  explicit PROTOBUF_CONSTEXPR IOStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  IOStatus(const IOStatus& from);
  IOStatus(IOStatus&& from) noexcept
    : IOStatus() {
    *this = ::std::move(from);
  }
 
  inline IOStatus& operator=(const IOStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline IOStatus& operator=(IOStatus&& 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 IOStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const IOStatus* internal_default_instance() {
    return reinterpret_cast<const IOStatus*>(
               &_IOStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;
 
  friend void swap(IOStatus& a, IOStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(IOStatus* 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(IOStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  IOStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IOStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IOStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IOStatus& from) {
    IOStatus::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(IOStatus* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.middleware.protobuf.IOStatus";
  }
  protected:
  explicit IOStatus(::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 {
    kErrorFieldNumber = 3,
    kIndexFieldNumber = 1,
    kStateFieldNumber = 2,
  };
  // optional .goby.middleware.protobuf.IOError error = 3;
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  const ::goby::middleware::protobuf::IOError& error() const;
  PROTOBUF_NODISCARD ::goby::middleware::protobuf::IOError* release_error();
  ::goby::middleware::protobuf::IOError* mutable_error();
  void set_allocated_error(::goby::middleware::protobuf::IOError* error);
  private:
  const ::goby::middleware::protobuf::IOError& _internal_error() const;
  ::goby::middleware::protobuf::IOError* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::goby::middleware::protobuf::IOError* error);
  ::goby::middleware::protobuf::IOError* unsafe_arena_release_error();
 
  // optional int32 index = 1 [default = -1];
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:
 
  // required .goby.middleware.protobuf.IOState state = 2;
  bool has_state() const;
  private:
  bool _internal_has_state() const;
  public:
  void clear_state();
  ::goby::middleware::protobuf::IOState state() const;
  void set_state(::goby::middleware::protobuf::IOState value);
  private:
  ::goby::middleware::protobuf::IOState _internal_state() const;
  void _internal_set_state(::goby::middleware::protobuf::IOState value);
  public:
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.IOStatus)
 private:
  class _Internal;
 
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::goby::middleware::protobuf::IOError* error_;
    int32_t index_;
    int state_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2fmiddleware_2fprotobuf_2fio_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// UDPEndPoint
 
// required string addr = 1;
inline bool UDPEndPoint::_internal_has_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UDPEndPoint::has_addr() const {
  return _internal_has_addr();
}
inline void UDPEndPoint::clear_addr() {
  _impl_.addr_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UDPEndPoint::addr() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.UDPEndPoint.addr)
  return _internal_addr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UDPEndPoint::set_addr(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.addr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.UDPEndPoint.addr)
}
inline std::string* UDPEndPoint::mutable_addr() {
  std::string* _s = _internal_mutable_addr();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.UDPEndPoint.addr)
  return _s;
}
inline const std::string& UDPEndPoint::_internal_addr() const {
  return _impl_.addr_.Get();
}
inline void UDPEndPoint::_internal_set_addr(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.addr_.Set(value, GetArenaForAllocation());
}
inline std::string* UDPEndPoint::_internal_mutable_addr() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.addr_.Mutable(GetArenaForAllocation());
}
inline std::string* UDPEndPoint::release_addr() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.UDPEndPoint.addr)
  if (!_internal_has_addr()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.addr_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addr_.IsDefault()) {
    _impl_.addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UDPEndPoint::set_allocated_addr(std::string* addr) {
  if (addr != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.addr_.SetAllocated(addr, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addr_.IsDefault()) {
    _impl_.addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.UDPEndPoint.addr)
}
 
// required uint32 port = 2;
inline bool UDPEndPoint::_internal_has_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UDPEndPoint::has_port() const {
  return _internal_has_port();
}
inline void UDPEndPoint::clear_port() {
  _impl_.port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t UDPEndPoint::_internal_port() const {
  return _impl_.port_;
}
inline uint32_t UDPEndPoint::port() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.UDPEndPoint.port)
  return _internal_port();
}
inline void UDPEndPoint::_internal_set_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.port_ = value;
}
inline void UDPEndPoint::set_port(uint32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.UDPEndPoint.port)
}
 
// -------------------------------------------------------------------
 
// TCPEndPoint
 
// optional string addr = 1;
inline bool TCPEndPoint::_internal_has_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TCPEndPoint::has_addr() const {
  return _internal_has_addr();
}
inline void TCPEndPoint::clear_addr() {
  _impl_.addr_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TCPEndPoint::addr() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPEndPoint.addr)
  return _internal_addr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TCPEndPoint::set_addr(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.addr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPEndPoint.addr)
}
inline std::string* TCPEndPoint::mutable_addr() {
  std::string* _s = _internal_mutable_addr();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.TCPEndPoint.addr)
  return _s;
}
inline const std::string& TCPEndPoint::_internal_addr() const {
  return _impl_.addr_.Get();
}
inline void TCPEndPoint::_internal_set_addr(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.addr_.Set(value, GetArenaForAllocation());
}
inline std::string* TCPEndPoint::_internal_mutable_addr() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.addr_.Mutable(GetArenaForAllocation());
}
inline std::string* TCPEndPoint::release_addr() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.TCPEndPoint.addr)
  if (!_internal_has_addr()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.addr_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addr_.IsDefault()) {
    _impl_.addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TCPEndPoint::set_allocated_addr(std::string* addr) {
  if (addr != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.addr_.SetAllocated(addr, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addr_.IsDefault()) {
    _impl_.addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.TCPEndPoint.addr)
}
 
// optional uint32 port = 2;
inline bool TCPEndPoint::_internal_has_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TCPEndPoint::has_port() const {
  return _internal_has_port();
}
inline void TCPEndPoint::clear_port() {
  _impl_.port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t TCPEndPoint::_internal_port() const {
  return _impl_.port_;
}
inline uint32_t TCPEndPoint::port() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPEndPoint.port)
  return _internal_port();
}
inline void TCPEndPoint::_internal_set_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.port_ = value;
}
inline void TCPEndPoint::set_port(uint32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPEndPoint.port)
}
 
// optional bool all_clients = 3 [default = false];
inline bool TCPEndPoint::_internal_has_all_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TCPEndPoint::has_all_clients() const {
  return _internal_has_all_clients();
}
inline void TCPEndPoint::clear_all_clients() {
  _impl_.all_clients_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool TCPEndPoint::_internal_all_clients() const {
  return _impl_.all_clients_;
}
inline bool TCPEndPoint::all_clients() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPEndPoint.all_clients)
  return _internal_all_clients();
}
inline void TCPEndPoint::_internal_set_all_clients(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.all_clients_ = value;
}
inline void TCPEndPoint::set_all_clients(bool value) {
  _internal_set_all_clients(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPEndPoint.all_clients)
}
 
// -------------------------------------------------------------------
 
// IOData
 
// optional int32 index = 1 [default = -1];
inline bool IOData::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IOData::has_index() const {
  return _internal_has_index();
}
inline void IOData::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t IOData::_internal_index() const {
  return _impl_.index_;
}
inline int32_t IOData::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.index)
  return _internal_index();
}
inline void IOData::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.index_ = value;
}
inline void IOData::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOData.index)
}
 
// .goby.middleware.protobuf.UDPEndPoint udp_src = 10;
inline bool IOData::_internal_has_udp_src() const {
  return src_case() == kUdpSrc;
}
inline bool IOData::has_udp_src() const {
  return _internal_has_udp_src();
}
inline void IOData::set_has_udp_src() {
  _impl_._oneof_case_[0] = kUdpSrc;
}
inline void IOData::clear_udp_src() {
  if (_internal_has_udp_src()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.src_.udp_src_;
    }
    clear_has_src();
  }
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::release_udp_src() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOData.udp_src)
  if (_internal_has_udp_src()) {
    clear_has_src();
    ::goby::middleware::protobuf::UDPEndPoint* temp = _impl_.src_.udp_src_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.src_.udp_src_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::goby::middleware::protobuf::UDPEndPoint& IOData::_internal_udp_src() const {
  return _internal_has_udp_src()
      ? *_impl_.src_.udp_src_
      : reinterpret_cast< ::goby::middleware::protobuf::UDPEndPoint&>(::goby::middleware::protobuf::_UDPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::UDPEndPoint& IOData::udp_src() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.udp_src)
  return _internal_udp_src();
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::unsafe_arena_release_udp_src() {
  // @@protoc_insertion_point(field_unsafe_arena_release:goby.middleware.protobuf.IOData.udp_src)
  if (_internal_has_udp_src()) {
    clear_has_src();
    ::goby::middleware::protobuf::UDPEndPoint* temp = _impl_.src_.udp_src_;
    _impl_.src_.udp_src_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IOData::unsafe_arena_set_allocated_udp_src(::goby::middleware::protobuf::UDPEndPoint* udp_src) {
  clear_src();
  if (udp_src) {
    set_has_udp_src();
    _impl_.src_.udp_src_ = udp_src;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.IOData.udp_src)
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::_internal_mutable_udp_src() {
  if (!_internal_has_udp_src()) {
    clear_src();
    set_has_udp_src();
    _impl_.src_.udp_src_ = CreateMaybeMessage< ::goby::middleware::protobuf::UDPEndPoint >(GetArenaForAllocation());
  }
  return _impl_.src_.udp_src_;
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::mutable_udp_src() {
  ::goby::middleware::protobuf::UDPEndPoint* _msg = _internal_mutable_udp_src();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOData.udp_src)
  return _msg;
}
 
// .goby.middleware.protobuf.TCPEndPoint tcp_src = 11;
inline bool IOData::_internal_has_tcp_src() const {
  return src_case() == kTcpSrc;
}
inline bool IOData::has_tcp_src() const {
  return _internal_has_tcp_src();
}
inline void IOData::set_has_tcp_src() {
  _impl_._oneof_case_[0] = kTcpSrc;
}
inline void IOData::clear_tcp_src() {
  if (_internal_has_tcp_src()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.src_.tcp_src_;
    }
    clear_has_src();
  }
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::release_tcp_src() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOData.tcp_src)
  if (_internal_has_tcp_src()) {
    clear_has_src();
    ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.src_.tcp_src_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.src_.tcp_src_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::goby::middleware::protobuf::TCPEndPoint& IOData::_internal_tcp_src() const {
  return _internal_has_tcp_src()
      ? *_impl_.src_.tcp_src_
      : reinterpret_cast< ::goby::middleware::protobuf::TCPEndPoint&>(::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& IOData::tcp_src() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.tcp_src)
  return _internal_tcp_src();
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::unsafe_arena_release_tcp_src() {
  // @@protoc_insertion_point(field_unsafe_arena_release:goby.middleware.protobuf.IOData.tcp_src)
  if (_internal_has_tcp_src()) {
    clear_has_src();
    ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.src_.tcp_src_;
    _impl_.src_.tcp_src_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IOData::unsafe_arena_set_allocated_tcp_src(::goby::middleware::protobuf::TCPEndPoint* tcp_src) {
  clear_src();
  if (tcp_src) {
    set_has_tcp_src();
    _impl_.src_.tcp_src_ = tcp_src;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.IOData.tcp_src)
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::_internal_mutable_tcp_src() {
  if (!_internal_has_tcp_src()) {
    clear_src();
    set_has_tcp_src();
    _impl_.src_.tcp_src_ = CreateMaybeMessage< ::goby::middleware::protobuf::TCPEndPoint >(GetArenaForAllocation());
  }
  return _impl_.src_.tcp_src_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::mutable_tcp_src() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_tcp_src();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOData.tcp_src)
  return _msg;
}
 
// .goby.middleware.protobuf.UDPEndPoint udp_dest = 20;
inline bool IOData::_internal_has_udp_dest() const {
  return dest_case() == kUdpDest;
}
inline bool IOData::has_udp_dest() const {
  return _internal_has_udp_dest();
}
inline void IOData::set_has_udp_dest() {
  _impl_._oneof_case_[1] = kUdpDest;
}
inline void IOData::clear_udp_dest() {
  if (_internal_has_udp_dest()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.dest_.udp_dest_;
    }
    clear_has_dest();
  }
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::release_udp_dest() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOData.udp_dest)
  if (_internal_has_udp_dest()) {
    clear_has_dest();
    ::goby::middleware::protobuf::UDPEndPoint* temp = _impl_.dest_.udp_dest_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.dest_.udp_dest_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::goby::middleware::protobuf::UDPEndPoint& IOData::_internal_udp_dest() const {
  return _internal_has_udp_dest()
      ? *_impl_.dest_.udp_dest_
      : reinterpret_cast< ::goby::middleware::protobuf::UDPEndPoint&>(::goby::middleware::protobuf::_UDPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::UDPEndPoint& IOData::udp_dest() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.udp_dest)
  return _internal_udp_dest();
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::unsafe_arena_release_udp_dest() {
  // @@protoc_insertion_point(field_unsafe_arena_release:goby.middleware.protobuf.IOData.udp_dest)
  if (_internal_has_udp_dest()) {
    clear_has_dest();
    ::goby::middleware::protobuf::UDPEndPoint* temp = _impl_.dest_.udp_dest_;
    _impl_.dest_.udp_dest_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IOData::unsafe_arena_set_allocated_udp_dest(::goby::middleware::protobuf::UDPEndPoint* udp_dest) {
  clear_dest();
  if (udp_dest) {
    set_has_udp_dest();
    _impl_.dest_.udp_dest_ = udp_dest;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.IOData.udp_dest)
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::_internal_mutable_udp_dest() {
  if (!_internal_has_udp_dest()) {
    clear_dest();
    set_has_udp_dest();
    _impl_.dest_.udp_dest_ = CreateMaybeMessage< ::goby::middleware::protobuf::UDPEndPoint >(GetArenaForAllocation());
  }
  return _impl_.dest_.udp_dest_;
}
inline ::goby::middleware::protobuf::UDPEndPoint* IOData::mutable_udp_dest() {
  ::goby::middleware::protobuf::UDPEndPoint* _msg = _internal_mutable_udp_dest();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOData.udp_dest)
  return _msg;
}
 
// .goby.middleware.protobuf.TCPEndPoint tcp_dest = 21;
inline bool IOData::_internal_has_tcp_dest() const {
  return dest_case() == kTcpDest;
}
inline bool IOData::has_tcp_dest() const {
  return _internal_has_tcp_dest();
}
inline void IOData::set_has_tcp_dest() {
  _impl_._oneof_case_[1] = kTcpDest;
}
inline void IOData::clear_tcp_dest() {
  if (_internal_has_tcp_dest()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.dest_.tcp_dest_;
    }
    clear_has_dest();
  }
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::release_tcp_dest() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOData.tcp_dest)
  if (_internal_has_tcp_dest()) {
    clear_has_dest();
    ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.dest_.tcp_dest_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.dest_.tcp_dest_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::goby::middleware::protobuf::TCPEndPoint& IOData::_internal_tcp_dest() const {
  return _internal_has_tcp_dest()
      ? *_impl_.dest_.tcp_dest_
      : reinterpret_cast< ::goby::middleware::protobuf::TCPEndPoint&>(::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& IOData::tcp_dest() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.tcp_dest)
  return _internal_tcp_dest();
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::unsafe_arena_release_tcp_dest() {
  // @@protoc_insertion_point(field_unsafe_arena_release:goby.middleware.protobuf.IOData.tcp_dest)
  if (_internal_has_tcp_dest()) {
    clear_has_dest();
    ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.dest_.tcp_dest_;
    _impl_.dest_.tcp_dest_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void IOData::unsafe_arena_set_allocated_tcp_dest(::goby::middleware::protobuf::TCPEndPoint* tcp_dest) {
  clear_dest();
  if (tcp_dest) {
    set_has_tcp_dest();
    _impl_.dest_.tcp_dest_ = tcp_dest;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.IOData.tcp_dest)
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::_internal_mutable_tcp_dest() {
  if (!_internal_has_tcp_dest()) {
    clear_dest();
    set_has_tcp_dest();
    _impl_.dest_.tcp_dest_ = CreateMaybeMessage< ::goby::middleware::protobuf::TCPEndPoint >(GetArenaForAllocation());
  }
  return _impl_.dest_.tcp_dest_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* IOData::mutable_tcp_dest() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_tcp_dest();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOData.tcp_dest)
  return _msg;
}
 
// optional bytes data = 30;
inline bool IOData::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IOData::has_data() const {
  return _internal_has_data();
}
inline void IOData::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IOData::data() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOData.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IOData::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOData.data)
}
inline std::string* IOData::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOData.data)
  return _s;
}
inline const std::string& IOData::_internal_data() const {
  return _impl_.data_.Get();
}
inline void IOData::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* IOData::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* IOData::release_data() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOData.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IOData::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.IOData.data)
}
 
inline bool IOData::has_src() const {
  return src_case() != SRC_NOT_SET;
}
inline void IOData::clear_has_src() {
  _impl_._oneof_case_[0] = SRC_NOT_SET;
}
inline bool IOData::has_dest() const {
  return dest_case() != DEST_NOT_SET;
}
inline void IOData::clear_has_dest() {
  _impl_._oneof_case_[1] = DEST_NOT_SET;
}
inline IOData::SrcCase IOData::src_case() const {
  return IOData::SrcCase(_impl_._oneof_case_[0]);
}
inline IOData::DestCase IOData::dest_case() const {
  return IOData::DestCase(_impl_._oneof_case_[1]);
}
// -------------------------------------------------------------------
 
// SerialCommand
 
// optional int32 index = 1 [default = -1];
inline bool SerialCommand::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SerialCommand::has_index() const {
  return _internal_has_index();
}
inline void SerialCommand::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t SerialCommand::_internal_index() const {
  return _impl_.index_;
}
inline int32_t SerialCommand::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.SerialCommand.index)
  return _internal_index();
}
inline void SerialCommand::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.index_ = value;
}
inline void SerialCommand::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.SerialCommand.index)
}
 
// required .goby.middleware.protobuf.SerialCommand.Command command = 2;
inline bool SerialCommand::_internal_has_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SerialCommand::has_command() const {
  return _internal_has_command();
}
inline void SerialCommand::clear_command() {
  _impl_.command_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::middleware::protobuf::SerialCommand_Command SerialCommand::_internal_command() const {
  return static_cast< ::goby::middleware::protobuf::SerialCommand_Command >(_impl_.command_);
}
inline ::goby::middleware::protobuf::SerialCommand_Command SerialCommand::command() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.SerialCommand.command)
  return _internal_command();
}
inline void SerialCommand::_internal_set_command(::goby::middleware::protobuf::SerialCommand_Command value) {
  assert(::goby::middleware::protobuf::SerialCommand_Command_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.command_ = value;
}
inline void SerialCommand::set_command(::goby::middleware::protobuf::SerialCommand_Command value) {
  _internal_set_command(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.SerialCommand.command)
}
 
// -------------------------------------------------------------------
 
// SerialStatus
 
// optional int32 index = 1 [default = -1];
inline bool SerialStatus::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SerialStatus::has_index() const {
  return _internal_has_index();
}
inline void SerialStatus::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SerialStatus::_internal_index() const {
  return _impl_.index_;
}
inline int32_t SerialStatus::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.SerialStatus.index)
  return _internal_index();
}
inline void SerialStatus::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.index_ = value;
}
inline void SerialStatus::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.SerialStatus.index)
}
 
// optional bool rts = 2;
inline bool SerialStatus::_internal_has_rts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SerialStatus::has_rts() const {
  return _internal_has_rts();
}
inline void SerialStatus::clear_rts() {
  _impl_.rts_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SerialStatus::_internal_rts() const {
  return _impl_.rts_;
}
inline bool SerialStatus::rts() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.SerialStatus.rts)
  return _internal_rts();
}
inline void SerialStatus::_internal_set_rts(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rts_ = value;
}
inline void SerialStatus::set_rts(bool value) {
  _internal_set_rts(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.SerialStatus.rts)
}
 
// optional bool dtr = 3;
inline bool SerialStatus::_internal_has_dtr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SerialStatus::has_dtr() const {
  return _internal_has_dtr();
}
inline void SerialStatus::clear_dtr() {
  _impl_.dtr_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SerialStatus::_internal_dtr() const {
  return _impl_.dtr_;
}
inline bool SerialStatus::dtr() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.SerialStatus.dtr)
  return _internal_dtr();
}
inline void SerialStatus::_internal_set_dtr(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dtr_ = value;
}
inline void SerialStatus::set_dtr(bool value) {
  _internal_set_dtr(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.SerialStatus.dtr)
}
 
// -------------------------------------------------------------------
 
// TCPServerEvent
 
// optional int32 index = 1 [default = -1];
inline bool TCPServerEvent::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool TCPServerEvent::has_index() const {
  return _internal_has_index();
}
inline void TCPServerEvent::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t TCPServerEvent::_internal_index() const {
  return _impl_.index_;
}
inline int32_t TCPServerEvent::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPServerEvent.index)
  return _internal_index();
}
inline void TCPServerEvent::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.index_ = value;
}
inline void TCPServerEvent::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPServerEvent.index)
}
 
// required .goby.middleware.protobuf.TCPServerEvent.Event event = 2;
inline bool TCPServerEvent::_internal_has_event() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TCPServerEvent::has_event() const {
  return _internal_has_event();
}
inline void TCPServerEvent::clear_event() {
  _impl_.event_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::middleware::protobuf::TCPServerEvent_Event TCPServerEvent::_internal_event() const {
  return static_cast< ::goby::middleware::protobuf::TCPServerEvent_Event >(_impl_.event_);
}
inline ::goby::middleware::protobuf::TCPServerEvent_Event TCPServerEvent::event() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPServerEvent.event)
  return _internal_event();
}
inline void TCPServerEvent::_internal_set_event(::goby::middleware::protobuf::TCPServerEvent_Event value) {
  assert(::goby::middleware::protobuf::TCPServerEvent_Event_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.event_ = value;
}
inline void TCPServerEvent::set_event(::goby::middleware::protobuf::TCPServerEvent_Event value) {
  _internal_set_event(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPServerEvent.event)
}
 
// optional .goby.middleware.protobuf.TCPEndPoint local_endpoint = 3;
inline bool TCPServerEvent::_internal_has_local_endpoint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.local_endpoint_ != nullptr);
  return value;
}
inline bool TCPServerEvent::has_local_endpoint() const {
  return _internal_has_local_endpoint();
}
inline void TCPServerEvent::clear_local_endpoint() {
  if (_impl_.local_endpoint_ != nullptr) _impl_.local_endpoint_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPServerEvent::_internal_local_endpoint() const {
  const ::goby::middleware::protobuf::TCPEndPoint* p = _impl_.local_endpoint_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TCPEndPoint&>(
      ::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPServerEvent::local_endpoint() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPServerEvent.local_endpoint)
  return _internal_local_endpoint();
}
inline void TCPServerEvent::unsafe_arena_set_allocated_local_endpoint(
    ::goby::middleware::protobuf::TCPEndPoint* local_endpoint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.local_endpoint_);
  }
  _impl_.local_endpoint_ = local_endpoint;
  if (local_endpoint) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.TCPServerEvent.local_endpoint)
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::release_local_endpoint() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.local_endpoint_;
  _impl_.local_endpoint_ = 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::protobuf::TCPEndPoint* TCPServerEvent::unsafe_arena_release_local_endpoint() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.TCPServerEvent.local_endpoint)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.local_endpoint_;
  _impl_.local_endpoint_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::_internal_mutable_local_endpoint() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.local_endpoint_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TCPEndPoint>(GetArenaForAllocation());
    _impl_.local_endpoint_ = p;
  }
  return _impl_.local_endpoint_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::mutable_local_endpoint() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_local_endpoint();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.TCPServerEvent.local_endpoint)
  return _msg;
}
inline void TCPServerEvent::set_allocated_local_endpoint(::goby::middleware::protobuf::TCPEndPoint* local_endpoint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.local_endpoint_;
  }
  if (local_endpoint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(local_endpoint);
    if (message_arena != submessage_arena) {
      local_endpoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_endpoint, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.local_endpoint_ = local_endpoint;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.TCPServerEvent.local_endpoint)
}
 
// optional .goby.middleware.protobuf.TCPEndPoint remote_endpoint = 4;
inline bool TCPServerEvent::_internal_has_remote_endpoint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remote_endpoint_ != nullptr);
  return value;
}
inline bool TCPServerEvent::has_remote_endpoint() const {
  return _internal_has_remote_endpoint();
}
inline void TCPServerEvent::clear_remote_endpoint() {
  if (_impl_.remote_endpoint_ != nullptr) _impl_.remote_endpoint_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPServerEvent::_internal_remote_endpoint() const {
  const ::goby::middleware::protobuf::TCPEndPoint* p = _impl_.remote_endpoint_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TCPEndPoint&>(
      ::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPServerEvent::remote_endpoint() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPServerEvent.remote_endpoint)
  return _internal_remote_endpoint();
}
inline void TCPServerEvent::unsafe_arena_set_allocated_remote_endpoint(
    ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remote_endpoint_);
  }
  _impl_.remote_endpoint_ = remote_endpoint;
  if (remote_endpoint) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.TCPServerEvent.remote_endpoint)
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::release_remote_endpoint() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.remote_endpoint_;
  _impl_.remote_endpoint_ = 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::protobuf::TCPEndPoint* TCPServerEvent::unsafe_arena_release_remote_endpoint() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.TCPServerEvent.remote_endpoint)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.remote_endpoint_;
  _impl_.remote_endpoint_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::_internal_mutable_remote_endpoint() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.remote_endpoint_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TCPEndPoint>(GetArenaForAllocation());
    _impl_.remote_endpoint_ = p;
  }
  return _impl_.remote_endpoint_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPServerEvent::mutable_remote_endpoint() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_remote_endpoint();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.TCPServerEvent.remote_endpoint)
  return _msg;
}
inline void TCPServerEvent::set_allocated_remote_endpoint(::goby::middleware::protobuf::TCPEndPoint* remote_endpoint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remote_endpoint_;
  }
  if (remote_endpoint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remote_endpoint);
    if (message_arena != submessage_arena) {
      remote_endpoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remote_endpoint, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.remote_endpoint_ = remote_endpoint;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.TCPServerEvent.remote_endpoint)
}
 
// optional int32 number_of_clients = 5;
inline bool TCPServerEvent::_internal_has_number_of_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool TCPServerEvent::has_number_of_clients() const {
  return _internal_has_number_of_clients();
}
inline void TCPServerEvent::clear_number_of_clients() {
  _impl_.number_of_clients_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t TCPServerEvent::_internal_number_of_clients() const {
  return _impl_.number_of_clients_;
}
inline int32_t TCPServerEvent::number_of_clients() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPServerEvent.number_of_clients)
  return _internal_number_of_clients();
}
inline void TCPServerEvent::_internal_set_number_of_clients(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.number_of_clients_ = value;
}
inline void TCPServerEvent::set_number_of_clients(int32_t value) {
  _internal_set_number_of_clients(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPServerEvent.number_of_clients)
}
 
// -------------------------------------------------------------------
 
// TCPClientEvent
 
// optional int32 index = 1 [default = -1];
inline bool TCPClientEvent::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TCPClientEvent::has_index() const {
  return _internal_has_index();
}
inline void TCPClientEvent::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t TCPClientEvent::_internal_index() const {
  return _impl_.index_;
}
inline int32_t TCPClientEvent::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPClientEvent.index)
  return _internal_index();
}
inline void TCPClientEvent::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.index_ = value;
}
inline void TCPClientEvent::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPClientEvent.index)
}
 
// required .goby.middleware.protobuf.TCPClientEvent.Event event = 2;
inline bool TCPClientEvent::_internal_has_event() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool TCPClientEvent::has_event() const {
  return _internal_has_event();
}
inline void TCPClientEvent::clear_event() {
  _impl_.event_ = 1;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::goby::middleware::protobuf::TCPClientEvent_Event TCPClientEvent::_internal_event() const {
  return static_cast< ::goby::middleware::protobuf::TCPClientEvent_Event >(_impl_.event_);
}
inline ::goby::middleware::protobuf::TCPClientEvent_Event TCPClientEvent::event() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPClientEvent.event)
  return _internal_event();
}
inline void TCPClientEvent::_internal_set_event(::goby::middleware::protobuf::TCPClientEvent_Event value) {
  assert(::goby::middleware::protobuf::TCPClientEvent_Event_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.event_ = value;
}
inline void TCPClientEvent::set_event(::goby::middleware::protobuf::TCPClientEvent_Event value) {
  _internal_set_event(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.TCPClientEvent.event)
}
 
// optional .goby.middleware.protobuf.TCPEndPoint local_endpoint = 3;
inline bool TCPClientEvent::_internal_has_local_endpoint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.local_endpoint_ != nullptr);
  return value;
}
inline bool TCPClientEvent::has_local_endpoint() const {
  return _internal_has_local_endpoint();
}
inline void TCPClientEvent::clear_local_endpoint() {
  if (_impl_.local_endpoint_ != nullptr) _impl_.local_endpoint_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPClientEvent::_internal_local_endpoint() const {
  const ::goby::middleware::protobuf::TCPEndPoint* p = _impl_.local_endpoint_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TCPEndPoint&>(
      ::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPClientEvent::local_endpoint() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPClientEvent.local_endpoint)
  return _internal_local_endpoint();
}
inline void TCPClientEvent::unsafe_arena_set_allocated_local_endpoint(
    ::goby::middleware::protobuf::TCPEndPoint* local_endpoint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.local_endpoint_);
  }
  _impl_.local_endpoint_ = local_endpoint;
  if (local_endpoint) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.TCPClientEvent.local_endpoint)
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::release_local_endpoint() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.local_endpoint_;
  _impl_.local_endpoint_ = 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::protobuf::TCPEndPoint* TCPClientEvent::unsafe_arena_release_local_endpoint() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.TCPClientEvent.local_endpoint)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.local_endpoint_;
  _impl_.local_endpoint_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::_internal_mutable_local_endpoint() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.local_endpoint_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TCPEndPoint>(GetArenaForAllocation());
    _impl_.local_endpoint_ = p;
  }
  return _impl_.local_endpoint_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::mutable_local_endpoint() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_local_endpoint();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.TCPClientEvent.local_endpoint)
  return _msg;
}
inline void TCPClientEvent::set_allocated_local_endpoint(::goby::middleware::protobuf::TCPEndPoint* local_endpoint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.local_endpoint_;
  }
  if (local_endpoint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(local_endpoint);
    if (message_arena != submessage_arena) {
      local_endpoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_endpoint, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.local_endpoint_ = local_endpoint;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.TCPClientEvent.local_endpoint)
}
 
// optional .goby.middleware.protobuf.TCPEndPoint remote_endpoint = 4;
inline bool TCPClientEvent::_internal_has_remote_endpoint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.remote_endpoint_ != nullptr);
  return value;
}
inline bool TCPClientEvent::has_remote_endpoint() const {
  return _internal_has_remote_endpoint();
}
inline void TCPClientEvent::clear_remote_endpoint() {
  if (_impl_.remote_endpoint_ != nullptr) _impl_.remote_endpoint_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPClientEvent::_internal_remote_endpoint() const {
  const ::goby::middleware::protobuf::TCPEndPoint* p = _impl_.remote_endpoint_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::TCPEndPoint&>(
      ::goby::middleware::protobuf::_TCPEndPoint_default_instance_);
}
inline const ::goby::middleware::protobuf::TCPEndPoint& TCPClientEvent::remote_endpoint() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.TCPClientEvent.remote_endpoint)
  return _internal_remote_endpoint();
}
inline void TCPClientEvent::unsafe_arena_set_allocated_remote_endpoint(
    ::goby::middleware::protobuf::TCPEndPoint* remote_endpoint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.remote_endpoint_);
  }
  _impl_.remote_endpoint_ = remote_endpoint;
  if (remote_endpoint) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.TCPClientEvent.remote_endpoint)
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::release_remote_endpoint() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.remote_endpoint_;
  _impl_.remote_endpoint_ = 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::protobuf::TCPEndPoint* TCPClientEvent::unsafe_arena_release_remote_endpoint() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.TCPClientEvent.remote_endpoint)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::goby::middleware::protobuf::TCPEndPoint* temp = _impl_.remote_endpoint_;
  _impl_.remote_endpoint_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::_internal_mutable_remote_endpoint() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.remote_endpoint_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::TCPEndPoint>(GetArenaForAllocation());
    _impl_.remote_endpoint_ = p;
  }
  return _impl_.remote_endpoint_;
}
inline ::goby::middleware::protobuf::TCPEndPoint* TCPClientEvent::mutable_remote_endpoint() {
  ::goby::middleware::protobuf::TCPEndPoint* _msg = _internal_mutable_remote_endpoint();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.TCPClientEvent.remote_endpoint)
  return _msg;
}
inline void TCPClientEvent::set_allocated_remote_endpoint(::goby::middleware::protobuf::TCPEndPoint* remote_endpoint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.remote_endpoint_;
  }
  if (remote_endpoint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(remote_endpoint);
    if (message_arena != submessage_arena) {
      remote_endpoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, remote_endpoint, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.remote_endpoint_ = remote_endpoint;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.TCPClientEvent.remote_endpoint)
}
 
// -------------------------------------------------------------------
 
// IOError
 
// required .goby.middleware.protobuf.IOError.ErrorCode code = 1;
inline bool IOError::_internal_has_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IOError::has_code() const {
  return _internal_has_code();
}
inline void IOError::clear_code() {
  _impl_.code_ = 1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::goby::middleware::protobuf::IOError_ErrorCode IOError::_internal_code() const {
  return static_cast< ::goby::middleware::protobuf::IOError_ErrorCode >(_impl_.code_);
}
inline ::goby::middleware::protobuf::IOError_ErrorCode IOError::code() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOError.code)
  return _internal_code();
}
inline void IOError::_internal_set_code(::goby::middleware::protobuf::IOError_ErrorCode value) {
  assert(::goby::middleware::protobuf::IOError_ErrorCode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.code_ = value;
}
inline void IOError::set_code(::goby::middleware::protobuf::IOError_ErrorCode value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOError.code)
}
 
// optional string text = 2;
inline bool IOError::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IOError::has_text() const {
  return _internal_has_text();
}
inline void IOError::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IOError::text() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOError.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IOError::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOError.text)
}
inline std::string* IOError::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOError.text)
  return _s;
}
inline const std::string& IOError::_internal_text() const {
  return _impl_.text_.Get();
}
inline void IOError::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* IOError::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* IOError::release_text() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOError.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void IOError::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.IOError.text)
}
 
// -------------------------------------------------------------------
 
// IOStatus
 
// optional int32 index = 1 [default = -1];
inline bool IOStatus::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IOStatus::has_index() const {
  return _internal_has_index();
}
inline void IOStatus::clear_index() {
  _impl_.index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t IOStatus::_internal_index() const {
  return _impl_.index_;
}
inline int32_t IOStatus::index() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOStatus.index)
  return _internal_index();
}
inline void IOStatus::_internal_set_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.index_ = value;
}
inline void IOStatus::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOStatus.index)
}
 
// required .goby.middleware.protobuf.IOState state = 2;
inline bool IOStatus::_internal_has_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool IOStatus::has_state() const {
  return _internal_has_state();
}
inline void IOStatus::clear_state() {
  _impl_.state_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::goby::middleware::protobuf::IOState IOStatus::_internal_state() const {
  return static_cast< ::goby::middleware::protobuf::IOState >(_impl_.state_);
}
inline ::goby::middleware::protobuf::IOState IOStatus::state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOStatus.state)
  return _internal_state();
}
inline void IOStatus::_internal_set_state(::goby::middleware::protobuf::IOState value) {
  assert(::goby::middleware::protobuf::IOState_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.state_ = value;
}
inline void IOStatus::set_state(::goby::middleware::protobuf::IOState value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.IOStatus.state)
}
 
// optional .goby.middleware.protobuf.IOError error = 3;
inline bool IOStatus::_internal_has_error() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.error_ != nullptr);
  return value;
}
inline bool IOStatus::has_error() const {
  return _internal_has_error();
}
inline void IOStatus::clear_error() {
  if (_impl_.error_ != nullptr) _impl_.error_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::goby::middleware::protobuf::IOError& IOStatus::_internal_error() const {
  const ::goby::middleware::protobuf::IOError* p = _impl_.error_;
  return p != nullptr ? *p : reinterpret_cast<const ::goby::middleware::protobuf::IOError&>(
      ::goby::middleware::protobuf::_IOError_default_instance_);
}
inline const ::goby::middleware::protobuf::IOError& IOStatus::error() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.IOStatus.error)
  return _internal_error();
}
inline void IOStatus::unsafe_arena_set_allocated_error(
    ::goby::middleware::protobuf::IOError* error) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.error_);
  }
  _impl_.error_ = error;
  if (error) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:goby.middleware.protobuf.IOStatus.error)
}
inline ::goby::middleware::protobuf::IOError* IOStatus::release_error() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::IOError* temp = _impl_.error_;
  _impl_.error_ = 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::protobuf::IOError* IOStatus::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.IOStatus.error)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::goby::middleware::protobuf::IOError* temp = _impl_.error_;
  _impl_.error_ = nullptr;
  return temp;
}
inline ::goby::middleware::protobuf::IOError* IOStatus::_internal_mutable_error() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.error_ == nullptr) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::IOError>(GetArenaForAllocation());
    _impl_.error_ = p;
  }
  return _impl_.error_;
}
inline ::goby::middleware::protobuf::IOError* IOStatus::mutable_error() {
  ::goby::middleware::protobuf::IOError* _msg = _internal_mutable_error();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.IOStatus.error)
  return _msg;
}
inline void IOStatus::set_allocated_error(::goby::middleware::protobuf::IOError* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.error_;
  }
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.error_ = error;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.IOStatus.error)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace middleware
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::middleware::protobuf::SerialCommand_Command> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::SerialCommand_Command>() {
  return ::goby::middleware::protobuf::SerialCommand_Command_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::protobuf::TCPServerEvent_Event> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::TCPServerEvent_Event>() {
  return ::goby::middleware::protobuf::TCPServerEvent_Event_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::protobuf::TCPClientEvent_Event> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::TCPClientEvent_Event>() {
  return ::goby::middleware::protobuf::TCPClientEvent_Event_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::protobuf::IOError_ErrorCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::IOError_ErrorCode>() {
  return ::goby::middleware::protobuf::IOError_ErrorCode_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::protobuf::IOState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::IOState>() {
  return ::goby::middleware::protobuf::IOState_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_2fio_2eproto