coroner.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/middleware/protobuf/coroner.proto
 
#ifndef PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto
#define PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_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/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "dccl/option_extensions.pb.h"
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
 
#include <boost/units/systems/si.hpp>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto 
 
namespace protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[4];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto
namespace goby {
namespace middleware {
namespace protobuf {
class HealthRequest;
class HealthRequestDefaultTypeInternal;
extern HealthRequestDefaultTypeInternal _HealthRequest_default_instance_;
class ProcessHealth;
class ProcessHealthDefaultTypeInternal;
extern ProcessHealthDefaultTypeInternal _ProcessHealth_default_instance_;
class ThreadHealth;
class ThreadHealthDefaultTypeInternal;
extern ThreadHealthDefaultTypeInternal _ThreadHealth_default_instance_;
class VehicleHealth;
class VehicleHealthDefaultTypeInternal;
extern VehicleHealthDefaultTypeInternal _VehicleHealth_default_instance_;
}  // namespace protobuf
}  // namespace middleware
}  // namespace goby
namespace google {
namespace protobuf {
template<> ::goby::middleware::protobuf::HealthRequest* Arena::CreateMaybeMessage<::goby::middleware::protobuf::HealthRequest>(Arena*);
template<> ::goby::middleware::protobuf::ProcessHealth* Arena::CreateMaybeMessage<::goby::middleware::protobuf::ProcessHealth>(Arena*);
template<> ::goby::middleware::protobuf::ThreadHealth* Arena::CreateMaybeMessage<::goby::middleware::protobuf::ThreadHealth>(Arena*);
template<> ::goby::middleware::protobuf::VehicleHealth* Arena::CreateMaybeMessage<::goby::middleware::protobuf::VehicleHealth>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace goby {
namespace middleware {
namespace protobuf {
 
enum HealthState {
  HEALTH__OK = 1,
  HEALTH__DEGRADED = 2,
  HEALTH__FAILED = 3
};
bool HealthState_IsValid(int value);
const HealthState HealthState_MIN = HEALTH__OK;
const HealthState HealthState_MAX = HEALTH__FAILED;
const int HealthState_ARRAYSIZE = HealthState_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* HealthState_descriptor();
inline const ::std::string& HealthState_Name(HealthState value) {
  return ::google::protobuf::internal::NameOfEnum(
    HealthState_descriptor(), value);
}
inline bool HealthState_Parse(
    const ::std::string& name, HealthState* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HealthState>(
    HealthState_descriptor(), name, value);
}
enum Error {
  ERROR__PROCESS_DIED = 1,
  ERROR__THREAD_NOT_RESPONDING = 100
};
bool Error_IsValid(int value);
const Error Error_MIN = ERROR__PROCESS_DIED;
const Error Error_MAX = ERROR__THREAD_NOT_RESPONDING;
const int Error_ARRAYSIZE = Error_MAX + 1;
 
const ::google::protobuf::EnumDescriptor* Error_descriptor();
inline const ::std::string& Error_Name(Error value) {
  return ::google::protobuf::internal::NameOfEnum(
    Error_descriptor(), value);
}
inline bool Error_Parse(
    const ::std::string& name, Error* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Error>(
    Error_descriptor(), name, value);
}
// ===================================================================
 
class HealthRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.HealthRequest) */ {
 public:
  HealthRequest();
  virtual ~HealthRequest();
 
  HealthRequest(const HealthRequest& from);
 
  inline HealthRequest& operator=(const HealthRequest& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HealthRequest(HealthRequest&& from) noexcept
    : HealthRequest() {
    *this = ::std::move(from);
  }
 
  inline HealthRequest& operator=(HealthRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const HealthRequest& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HealthRequest* internal_default_instance() {
    return reinterpret_cast<const HealthRequest*>(
               &_HealthRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  void Swap(HealthRequest* other);
  friend void swap(HealthRequest& a, HealthRequest& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline HealthRequest* New() const final {
    return CreateMaybeMessage<HealthRequest>(NULL);
  }
 
  HealthRequest* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<HealthRequest>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const HealthRequest& from);
  void MergeFrom(const HealthRequest& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HealthRequest* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.HealthRequest)
 private:
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ThreadHealth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.ThreadHealth) */ {
 public:
  ThreadHealth();
  virtual ~ThreadHealth();
 
  ThreadHealth(const ThreadHealth& from);
 
  inline ThreadHealth& operator=(const ThreadHealth& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ThreadHealth(ThreadHealth&& from) noexcept
    : ThreadHealth() {
    *this = ::std::move(from);
  }
 
  inline ThreadHealth& operator=(ThreadHealth&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ThreadHealth& default_instance();
 
  enum TIdCase {
    kThreadId = 2,
    kThreadIdApple = 4,
    T_ID_NOT_SET = 0,
  };
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ThreadHealth* internal_default_instance() {
    return reinterpret_cast<const ThreadHealth*>(
               &_ThreadHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  void Swap(ThreadHealth* other);
  friend void swap(ThreadHealth& a, ThreadHealth& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ThreadHealth* New() const final {
    return CreateMaybeMessage<ThreadHealth>(NULL);
  }
 
  ThreadHealth* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ThreadHealth>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ThreadHealth& from);
  void MergeFrom(const ThreadHealth& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ThreadHealth* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .goby.middleware.protobuf.ThreadHealth child = 11;
  int child_size() const;
  void clear_child();
  static const int kChildFieldNumber = 11;
  ::goby::middleware::protobuf::ThreadHealth* mutable_child(int index);
  ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ThreadHealth >*
      mutable_child();
  const ::goby::middleware::protobuf::ThreadHealth& child(int index) const;
  ::goby::middleware::protobuf::ThreadHealth* add_child();
  const ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ThreadHealth >&
      child() const;
 
  // required string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);
 
  // optional string error_message = 21;
  bool has_error_message() const;
  void clear_error_message();
  static const int kErrorMessageFieldNumber = 21;
  const ::std::string& error_message() const;
  void set_error_message(const ::std::string& value);
  #if LANG_CXX11
  void set_error_message(::std::string&& value);
  #endif
  void set_error_message(const char* value);
  void set_error_message(const char* value, size_t size);
  ::std::string* mutable_error_message();
  ::std::string* release_error_message();
  void set_allocated_error_message(::std::string* error_message);
 
  // optional int32 uid = 3;
  bool has_uid() const;
  void clear_uid();
  static const int kUidFieldNumber = 3;
  ::google::protobuf::int32 uid() const;
  void set_uid(::google::protobuf::int32 value);
 
  // required .goby.middleware.protobuf.HealthState state = 10;
  bool has_state() const;
  void clear_state();
  static const int kStateFieldNumber = 10;
  ::goby::middleware::protobuf::HealthState state() const;
  void set_state(::goby::middleware::protobuf::HealthState value);
 
  // optional .goby.middleware.protobuf.Error error = 20;
  bool has_error() const;
  void clear_error();
  static const int kErrorFieldNumber = 20;
  ::goby::middleware::protobuf::Error error() const;
  void set_error(::goby::middleware::protobuf::Error value);
 
  // optional int32 thread_id = 2;
  bool has_thread_id() const;
  void clear_thread_id();
  static const int kThreadIdFieldNumber = 2;
  ::google::protobuf::int32 thread_id() const;
  void set_thread_id(::google::protobuf::int32 value);
 
  // optional uint64 thread_id_apple = 4;
  bool has_thread_id_apple() const;
  void clear_thread_id_apple();
  static const int kThreadIdAppleFieldNumber = 4;
  ::google::protobuf::uint64 thread_id_apple() const;
  void set_thread_id_apple(::google::protobuf::uint64 value);
 
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ThreadHealth)
  void clear_t_id();
  TIdCase t_id_case() const;
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.ThreadHealth)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_thread_id();
  void set_has_thread_id_apple();
  void set_has_uid();
  void clear_has_uid();
  void set_has_state();
  void clear_has_state();
  void set_has_error();
  void clear_has_error();
  void set_has_error_message();
  void clear_has_error_message();
 
  inline bool has_t_id() const;
  inline void clear_has_t_id();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ThreadHealth > child_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr error_message_;
  ::google::protobuf::int32 uid_;
  int state_;
  int error_;
  union TIdUnion {
    TIdUnion() {}
    ::google::protobuf::int32 thread_id_;
    ::google::protobuf::uint64 thread_id_apple_;
  } t_id_;
  ::google::protobuf::uint32 _oneof_case_[1];
 
  friend struct ::protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class ProcessHealth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.ProcessHealth) */ {
 public:
  ProcessHealth();
  virtual ~ProcessHealth();
 
  ProcessHealth(const ProcessHealth& from);
 
  inline ProcessHealth& operator=(const ProcessHealth& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ProcessHealth(ProcessHealth&& from) noexcept
    : ProcessHealth() {
    *this = ::std::move(from);
  }
 
  inline ProcessHealth& operator=(ProcessHealth&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ProcessHealth& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ProcessHealth* internal_default_instance() {
    return reinterpret_cast<const ProcessHealth*>(
               &_ProcessHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;
 
  void Swap(ProcessHealth* other);
  friend void swap(ProcessHealth& a, ProcessHealth& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline ProcessHealth* New() const final {
    return CreateMaybeMessage<ProcessHealth>(NULL);
  }
 
  ProcessHealth* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ProcessHealth>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ProcessHealth& from);
  void MergeFrom(const ProcessHealth& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProcessHealth* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // required string name = 1;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);
 
  // required .goby.middleware.protobuf.ThreadHealth main = 10;
  bool has_main() const;
  void clear_main();
  static const int kMainFieldNumber = 10;
  private:
  const ::goby::middleware::protobuf::ThreadHealth& _internal_main() const;
  public:
  const ::goby::middleware::protobuf::ThreadHealth& main() const;
  ::goby::middleware::protobuf::ThreadHealth* release_main();
  ::goby::middleware::protobuf::ThreadHealth* mutable_main();
  void set_allocated_main(::goby::middleware::protobuf::ThreadHealth* main);
 
  // optional uint32 pid = 2;
  bool has_pid() const;
  void clear_pid();
  static const int kPidFieldNumber = 2;
  ::google::protobuf::uint32 pid() const;
  void set_pid(::google::protobuf::uint32 value);
 
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ProcessHealth)
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.ProcessHealth)
 private:
  void set_has_name();
  void clear_has_name();
  void set_has_pid();
  void clear_has_pid();
  void set_has_main();
  void clear_has_main();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::goby::middleware::protobuf::ThreadHealth* main_;
  ::google::protobuf::uint32 pid_;
  friend struct ::protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto::TableStruct;
};
// -------------------------------------------------------------------
 
class VehicleHealth : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:goby.middleware.protobuf.VehicleHealth) */ {
 public:
  VehicleHealth();
  virtual ~VehicleHealth();
 
  VehicleHealth(const VehicleHealth& from);
 
  inline VehicleHealth& operator=(const VehicleHealth& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  VehicleHealth(VehicleHealth&& from) noexcept
    : VehicleHealth() {
    *this = ::std::move(from);
  }
 
  inline VehicleHealth& operator=(VehicleHealth&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const VehicleHealth& default_instance();
 
  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const VehicleHealth* internal_default_instance() {
    return reinterpret_cast<const VehicleHealth*>(
               &_VehicleHealth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;
 
  void Swap(VehicleHealth* other);
  friend void swap(VehicleHealth& a, VehicleHealth& b) {
    a.Swap(&b);
  }
 
  // implements Message ----------------------------------------------
 
  inline VehicleHealth* New() const final {
    return CreateMaybeMessage<VehicleHealth>(NULL);
  }
 
  VehicleHealth* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<VehicleHealth>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const VehicleHealth& from);
  void MergeFrom(const VehicleHealth& from);
  void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VehicleHealth* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:
 
  ::google::protobuf::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .goby.middleware.protobuf.ProcessHealth process = 11;
  int process_size() const;
  void clear_process();
  static const int kProcessFieldNumber = 11;
  ::goby::middleware::protobuf::ProcessHealth* mutable_process(int index);
  ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ProcessHealth >*
      mutable_process();
  const ::goby::middleware::protobuf::ProcessHealth& process(int index) const;
  ::goby::middleware::protobuf::ProcessHealth* add_process();
  const ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ProcessHealth >&
      process() const;
 
  // required string platform = 2;
  bool has_platform() const;
  void clear_platform();
  static const int kPlatformFieldNumber = 2;
  const ::std::string& platform() const;
  void set_platform(const ::std::string& value);
  #if LANG_CXX11
  void set_platform(::std::string&& value);
  #endif
  void set_platform(const char* value);
  void set_platform(const char* value, size_t size);
  ::std::string* mutable_platform();
  ::std::string* release_platform();
  void set_allocated_platform(::std::string* platform);
 
  // required uint64 time = 1 [(.dccl.field) = {
  bool has_time() const;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::uint64 time() const;
  void set_time(::google::protobuf::uint64 value);
 
  // required .goby.middleware.protobuf.HealthState state = 10;
  bool has_state() const;
  void clear_state();
  static const int kStateFieldNumber = 10;
  ::goby::middleware::protobuf::HealthState state() const;
  void set_state(::goby::middleware::protobuf::HealthState value);
 
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(VehicleHealth)
  typedef boost::units::derived_dimension< boost::units::time_base_dimension,1 >::type time_dimension;
  
  typedef boost::units::make_scaled_unit<boost::units::unit<time_dimension,boost::units::si::system> , boost::units::scale<10, boost::units::static_rational<-6> > >::type time_unit;
  
  template<typename Quantity >
    void set_time_with_units(Quantity value_w_units)
    { set_time(boost::units::quantity<time_unit,google::protobuf::uint64 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity time_with_units() const
    { return Quantity(time() * time_unit()); };
  
  boost::units::quantity< time_unit,google::protobuf::uint64 > time_with_units() const
    { return time_with_units<boost::units::quantity< time_unit,google::protobuf::uint64 > >(); };
  
  // @@protoc_insertion_point(class_scope:goby.middleware.protobuf.VehicleHealth)
 private:
  void set_has_time();
  void clear_has_time();
  void set_has_platform();
  void clear_has_platform();
  void set_has_state();
  void clear_has_state();
 
  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;
 
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ProcessHealth > process_;
  ::google::protobuf::internal::ArenaStringPtr platform_;
  ::google::protobuf::uint64 time_;
  int state_;
  friend struct ::protobuf_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto::TableStruct;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// HealthRequest
 
// -------------------------------------------------------------------
 
// ThreadHealth
 
// required string name = 1;
inline bool ThreadHealth::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ThreadHealth::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ThreadHealth::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ThreadHealth::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& ThreadHealth::name() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.name)
  return name_.GetNoArena();
}
inline void ThreadHealth::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.name)
}
#if LANG_CXX11
inline void ThreadHealth::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.middleware.protobuf.ThreadHealth.name)
}
#endif
inline void ThreadHealth::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.middleware.protobuf.ThreadHealth.name)
}
inline void ThreadHealth::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.middleware.protobuf.ThreadHealth.name)
}
inline ::std::string* ThreadHealth::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.ThreadHealth.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ThreadHealth::release_name() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.ThreadHealth.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ThreadHealth::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.ThreadHealth.name)
}
 
// optional int32 thread_id = 2;
inline bool ThreadHealth::has_thread_id() const {
  return t_id_case() == kThreadId;
}
inline void ThreadHealth::set_has_thread_id() {
  _oneof_case_[0] = kThreadId;
}
inline void ThreadHealth::clear_thread_id() {
  if (has_thread_id()) {
    t_id_.thread_id_ = 0;
    clear_has_t_id();
  }
}
inline ::google::protobuf::int32 ThreadHealth::thread_id() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.thread_id)
  if (has_thread_id()) {
    return t_id_.thread_id_;
  }
  return 0;
}
inline void ThreadHealth::set_thread_id(::google::protobuf::int32 value) {
  if (!has_thread_id()) {
    clear_t_id();
    set_has_thread_id();
  }
  t_id_.thread_id_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.thread_id)
}
 
// optional uint64 thread_id_apple = 4;
inline bool ThreadHealth::has_thread_id_apple() const {
  return t_id_case() == kThreadIdApple;
}
inline void ThreadHealth::set_has_thread_id_apple() {
  _oneof_case_[0] = kThreadIdApple;
}
inline void ThreadHealth::clear_thread_id_apple() {
  if (has_thread_id_apple()) {
    t_id_.thread_id_apple_ = GOOGLE_ULONGLONG(0);
    clear_has_t_id();
  }
}
inline ::google::protobuf::uint64 ThreadHealth::thread_id_apple() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.thread_id_apple)
  if (has_thread_id_apple()) {
    return t_id_.thread_id_apple_;
  }
  return GOOGLE_ULONGLONG(0);
}
inline void ThreadHealth::set_thread_id_apple(::google::protobuf::uint64 value) {
  if (!has_thread_id_apple()) {
    clear_t_id();
    set_has_thread_id_apple();
  }
  t_id_.thread_id_apple_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.thread_id_apple)
}
 
// optional int32 uid = 3;
inline bool ThreadHealth::has_uid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ThreadHealth::set_has_uid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ThreadHealth::clear_has_uid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ThreadHealth::clear_uid() {
  uid_ = 0;
  clear_has_uid();
}
inline ::google::protobuf::int32 ThreadHealth::uid() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.uid)
  return uid_;
}
inline void ThreadHealth::set_uid(::google::protobuf::int32 value) {
  set_has_uid();
  uid_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.uid)
}
 
// required .goby.middleware.protobuf.HealthState state = 10;
inline bool ThreadHealth::has_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ThreadHealth::set_has_state() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ThreadHealth::clear_has_state() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ThreadHealth::clear_state() {
  state_ = 1;
  clear_has_state();
}
inline ::goby::middleware::protobuf::HealthState ThreadHealth::state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.state)
  return static_cast< ::goby::middleware::protobuf::HealthState >(state_);
}
inline void ThreadHealth::set_state(::goby::middleware::protobuf::HealthState value) {
  assert(::goby::middleware::protobuf::HealthState_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.state)
}
 
// repeated .goby.middleware.protobuf.ThreadHealth child = 11;
inline int ThreadHealth::child_size() const {
  return child_.size();
}
inline void ThreadHealth::clear_child() {
  child_.Clear();
}
inline ::goby::middleware::protobuf::ThreadHealth* ThreadHealth::mutable_child(int index) {
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.ThreadHealth.child)
  return child_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ThreadHealth >*
ThreadHealth::mutable_child() {
  // @@protoc_insertion_point(field_mutable_list:goby.middleware.protobuf.ThreadHealth.child)
  return &child_;
}
inline const ::goby::middleware::protobuf::ThreadHealth& ThreadHealth::child(int index) const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.child)
  return child_.Get(index);
}
inline ::goby::middleware::protobuf::ThreadHealth* ThreadHealth::add_child() {
  // @@protoc_insertion_point(field_add:goby.middleware.protobuf.ThreadHealth.child)
  return child_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ThreadHealth >&
ThreadHealth::child() const {
  // @@protoc_insertion_point(field_list:goby.middleware.protobuf.ThreadHealth.child)
  return child_;
}
 
// optional .goby.middleware.protobuf.Error error = 20;
inline bool ThreadHealth::has_error() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ThreadHealth::set_has_error() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ThreadHealth::clear_has_error() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ThreadHealth::clear_error() {
  error_ = 1;
  clear_has_error();
}
inline ::goby::middleware::protobuf::Error ThreadHealth::error() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.error)
  return static_cast< ::goby::middleware::protobuf::Error >(error_);
}
inline void ThreadHealth::set_error(::goby::middleware::protobuf::Error value) {
  assert(::goby::middleware::protobuf::Error_IsValid(value));
  set_has_error();
  error_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.error)
}
 
// optional string error_message = 21;
inline bool ThreadHealth::has_error_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ThreadHealth::set_has_error_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ThreadHealth::clear_has_error_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ThreadHealth::clear_error_message() {
  error_message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_error_message();
}
inline const ::std::string& ThreadHealth::error_message() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ThreadHealth.error_message)
  return error_message_.GetNoArena();
}
inline void ThreadHealth::set_error_message(const ::std::string& value) {
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ThreadHealth.error_message)
}
#if LANG_CXX11
inline void ThreadHealth::set_error_message(::std::string&& value) {
  set_has_error_message();
  error_message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.middleware.protobuf.ThreadHealth.error_message)
}
#endif
inline void ThreadHealth::set_error_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.middleware.protobuf.ThreadHealth.error_message)
}
inline void ThreadHealth::set_error_message(const char* value, size_t size) {
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.middleware.protobuf.ThreadHealth.error_message)
}
inline ::std::string* ThreadHealth::mutable_error_message() {
  set_has_error_message();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.ThreadHealth.error_message)
  return error_message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ThreadHealth::release_error_message() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.ThreadHealth.error_message)
  if (!has_error_message()) {
    return NULL;
  }
  clear_has_error_message();
  return error_message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ThreadHealth::set_allocated_error_message(::std::string* error_message) {
  if (error_message != NULL) {
    set_has_error_message();
  } else {
    clear_has_error_message();
  }
  error_message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_message);
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.ThreadHealth.error_message)
}
 
inline bool ThreadHealth::has_t_id() const {
  return t_id_case() != T_ID_NOT_SET;
}
inline void ThreadHealth::clear_has_t_id() {
  _oneof_case_[0] = T_ID_NOT_SET;
}
inline ThreadHealth::TIdCase ThreadHealth::t_id_case() const {
  return ThreadHealth::TIdCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// ProcessHealth
 
// required string name = 1;
inline bool ProcessHealth::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ProcessHealth::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ProcessHealth::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ProcessHealth::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& ProcessHealth::name() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ProcessHealth.name)
  return name_.GetNoArena();
}
inline void ProcessHealth::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ProcessHealth.name)
}
#if LANG_CXX11
inline void ProcessHealth::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.middleware.protobuf.ProcessHealth.name)
}
#endif
inline void ProcessHealth::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.middleware.protobuf.ProcessHealth.name)
}
inline void ProcessHealth::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.middleware.protobuf.ProcessHealth.name)
}
inline ::std::string* ProcessHealth::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.ProcessHealth.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ProcessHealth::release_name() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.ProcessHealth.name)
  if (!has_name()) {
    return NULL;
  }
  clear_has_name();
  return name_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ProcessHealth::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.ProcessHealth.name)
}
 
// optional uint32 pid = 2;
inline bool ProcessHealth::has_pid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ProcessHealth::set_has_pid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ProcessHealth::clear_has_pid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ProcessHealth::clear_pid() {
  pid_ = 0u;
  clear_has_pid();
}
inline ::google::protobuf::uint32 ProcessHealth::pid() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ProcessHealth.pid)
  return pid_;
}
inline void ProcessHealth::set_pid(::google::protobuf::uint32 value) {
  set_has_pid();
  pid_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.ProcessHealth.pid)
}
 
// required .goby.middleware.protobuf.ThreadHealth main = 10;
inline bool ProcessHealth::has_main() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ProcessHealth::set_has_main() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ProcessHealth::clear_has_main() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ProcessHealth::clear_main() {
  if (main_ != NULL) main_->Clear();
  clear_has_main();
}
inline const ::goby::middleware::protobuf::ThreadHealth& ProcessHealth::_internal_main() const {
  return *main_;
}
inline const ::goby::middleware::protobuf::ThreadHealth& ProcessHealth::main() const {
  const ::goby::middleware::protobuf::ThreadHealth* p = main_;
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.ProcessHealth.main)
  return p != NULL ? *p : *reinterpret_cast<const ::goby::middleware::protobuf::ThreadHealth*>(
      &::goby::middleware::protobuf::_ThreadHealth_default_instance_);
}
inline ::goby::middleware::protobuf::ThreadHealth* ProcessHealth::release_main() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.ProcessHealth.main)
  clear_has_main();
  ::goby::middleware::protobuf::ThreadHealth* temp = main_;
  main_ = NULL;
  return temp;
}
inline ::goby::middleware::protobuf::ThreadHealth* ProcessHealth::mutable_main() {
  set_has_main();
  if (main_ == NULL) {
    auto* p = CreateMaybeMessage<::goby::middleware::protobuf::ThreadHealth>(GetArenaNoVirtual());
    main_ = p;
  }
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.ProcessHealth.main)
  return main_;
}
inline void ProcessHealth::set_allocated_main(::goby::middleware::protobuf::ThreadHealth* main) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete main_;
  }
  if (main) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      main = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, main, submessage_arena);
    }
    set_has_main();
  } else {
    clear_has_main();
  }
  main_ = main;
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.ProcessHealth.main)
}
 
// -------------------------------------------------------------------
 
// VehicleHealth
 
// required uint64 time = 1 [(.dccl.field) = {
inline bool VehicleHealth::has_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VehicleHealth::set_has_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void VehicleHealth::clear_has_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void VehicleHealth::clear_time() {
  time_ = GOOGLE_ULONGLONG(0);
  clear_has_time();
}
inline ::google::protobuf::uint64 VehicleHealth::time() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.VehicleHealth.time)
  return time_;
}
inline void VehicleHealth::set_time(::google::protobuf::uint64 value) {
  set_has_time();
  time_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.VehicleHealth.time)
}
 
// required string platform = 2;
inline bool VehicleHealth::has_platform() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VehicleHealth::set_has_platform() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VehicleHealth::clear_has_platform() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VehicleHealth::clear_platform() {
  platform_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_platform();
}
inline const ::std::string& VehicleHealth::platform() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.VehicleHealth.platform)
  return platform_.GetNoArena();
}
inline void VehicleHealth::set_platform(const ::std::string& value) {
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.VehicleHealth.platform)
}
#if LANG_CXX11
inline void VehicleHealth::set_platform(::std::string&& value) {
  set_has_platform();
  platform_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:goby.middleware.protobuf.VehicleHealth.platform)
}
#endif
inline void VehicleHealth::set_platform(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:goby.middleware.protobuf.VehicleHealth.platform)
}
inline void VehicleHealth::set_platform(const char* value, size_t size) {
  set_has_platform();
  platform_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:goby.middleware.protobuf.VehicleHealth.platform)
}
inline ::std::string* VehicleHealth::mutable_platform() {
  set_has_platform();
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.VehicleHealth.platform)
  return platform_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* VehicleHealth::release_platform() {
  // @@protoc_insertion_point(field_release:goby.middleware.protobuf.VehicleHealth.platform)
  if (!has_platform()) {
    return NULL;
  }
  clear_has_platform();
  return platform_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void VehicleHealth::set_allocated_platform(::std::string* platform) {
  if (platform != NULL) {
    set_has_platform();
  } else {
    clear_has_platform();
  }
  platform_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), platform);
  // @@protoc_insertion_point(field_set_allocated:goby.middleware.protobuf.VehicleHealth.platform)
}
 
// required .goby.middleware.protobuf.HealthState state = 10;
inline bool VehicleHealth::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VehicleHealth::set_has_state() {
  _has_bits_[0] |= 0x00000004u;
}
inline void VehicleHealth::clear_has_state() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void VehicleHealth::clear_state() {
  state_ = 1;
  clear_has_state();
}
inline ::goby::middleware::protobuf::HealthState VehicleHealth::state() const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.VehicleHealth.state)
  return static_cast< ::goby::middleware::protobuf::HealthState >(state_);
}
inline void VehicleHealth::set_state(::goby::middleware::protobuf::HealthState value) {
  assert(::goby::middleware::protobuf::HealthState_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:goby.middleware.protobuf.VehicleHealth.state)
}
 
// repeated .goby.middleware.protobuf.ProcessHealth process = 11;
inline int VehicleHealth::process_size() const {
  return process_.size();
}
inline void VehicleHealth::clear_process() {
  process_.Clear();
}
inline ::goby::middleware::protobuf::ProcessHealth* VehicleHealth::mutable_process(int index) {
  // @@protoc_insertion_point(field_mutable:goby.middleware.protobuf.VehicleHealth.process)
  return process_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ProcessHealth >*
VehicleHealth::mutable_process() {
  // @@protoc_insertion_point(field_mutable_list:goby.middleware.protobuf.VehicleHealth.process)
  return &process_;
}
inline const ::goby::middleware::protobuf::ProcessHealth& VehicleHealth::process(int index) const {
  // @@protoc_insertion_point(field_get:goby.middleware.protobuf.VehicleHealth.process)
  return process_.Get(index);
}
inline ::goby::middleware::protobuf::ProcessHealth* VehicleHealth::add_process() {
  // @@protoc_insertion_point(field_add:goby.middleware.protobuf.VehicleHealth.process)
  return process_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::goby::middleware::protobuf::ProcessHealth >&
VehicleHealth::process() const {
  // @@protoc_insertion_point(field_list:goby.middleware.protobuf.VehicleHealth.process)
  return process_;
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace middleware
}  // namespace goby
 
namespace google {
namespace protobuf {
 
template <> struct is_proto_enum< ::goby::middleware::protobuf::HealthState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::HealthState>() {
  return ::goby::middleware::protobuf::HealthState_descriptor();
}
template <> struct is_proto_enum< ::goby::middleware::protobuf::Error> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::middleware::protobuf::Error>() {
  return ::goby::middleware::protobuf::Error_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_INCLUDED_goby_2fmiddleware_2fprotobuf_2fcoroner_2eproto