ais.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: goby/util/protobuf/ais.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_goby_2futil_2fprotobuf_2fais_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_goby_2futil_2fprotobuf_2fais_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 "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/angle/degrees.hpp>
 
#include <boost/units/systems/si.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_goby_2futil_2fprotobuf_2fais_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_goby_2futil_2fprotobuf_2fais_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_goby_2futil_2fprotobuf_2fais_2eproto;
namespace goby {
namespace util {
namespace ais {
namespace protobuf {
class Position;
struct PositionDefaultTypeInternal;
extern PositionDefaultTypeInternal _Position_default_instance_;
class Voyage;
struct VoyageDefaultTypeInternal;
extern VoyageDefaultTypeInternal _Voyage_default_instance_;
}  // namespace protobuf
}  // namespace ais
}  // namespace util
}  // namespace goby
PROTOBUF_NAMESPACE_OPEN
template<> ::goby::util::ais::protobuf::Position* Arena::CreateMaybeMessage<::goby::util::ais::protobuf::Position>(Arena*);
template<> ::goby::util::ais::protobuf::Voyage* Arena::CreateMaybeMessage<::goby::util::ais::protobuf::Voyage>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace goby {
namespace util {
namespace ais {
namespace protobuf {
 
enum Position_TurnInfo : int {
  Position_TurnInfo_TURN_INFO__NOT_TURNING = 0,
  Position_TurnInfo_TURN_INFO__TURNING_AT_GIVEN_RATE = 1,
  Position_TurnInfo_TURN_INFO__TURNING_RIGHT_AT_MORE_THAN_5_DEG_PER_30_SEC = 127,
  Position_TurnInfo_TURN_INFO__TURNING_LEFT_AT_MORE_THAN_5_DEG_PER_30_SEC = -127,
  Position_TurnInfo_TURN_INFO__NO_TURN_INFORMATION = 128
};
bool Position_TurnInfo_IsValid(int value);
constexpr Position_TurnInfo Position_TurnInfo_TurnInfo_MIN = Position_TurnInfo_TURN_INFO__TURNING_LEFT_AT_MORE_THAN_5_DEG_PER_30_SEC;
constexpr Position_TurnInfo Position_TurnInfo_TurnInfo_MAX = Position_TurnInfo_TURN_INFO__NO_TURN_INFORMATION;
constexpr int Position_TurnInfo_TurnInfo_ARRAYSIZE = Position_TurnInfo_TurnInfo_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Position_TurnInfo_descriptor();
template<typename T>
inline const std::string& Position_TurnInfo_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Position_TurnInfo>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Position_TurnInfo_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Position_TurnInfo_descriptor(), enum_t_value);
}
inline bool Position_TurnInfo_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Position_TurnInfo* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Position_TurnInfo>(
    Position_TurnInfo_descriptor(), name, value);
}
enum Position_PositionAccuracy : int {
  Position_PositionAccuracy_ACCURACY__LOW__ABOVE_10_METERS = 0,
  Position_PositionAccuracy_ACCURACY__HIGH__BELOW_10_METERS = 1
};
bool Position_PositionAccuracy_IsValid(int value);
constexpr Position_PositionAccuracy Position_PositionAccuracy_PositionAccuracy_MIN = Position_PositionAccuracy_ACCURACY__LOW__ABOVE_10_METERS;
constexpr Position_PositionAccuracy Position_PositionAccuracy_PositionAccuracy_MAX = Position_PositionAccuracy_ACCURACY__HIGH__BELOW_10_METERS;
constexpr int Position_PositionAccuracy_PositionAccuracy_ARRAYSIZE = Position_PositionAccuracy_PositionAccuracy_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Position_PositionAccuracy_descriptor();
template<typename T>
inline const std::string& Position_PositionAccuracy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Position_PositionAccuracy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Position_PositionAccuracy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Position_PositionAccuracy_descriptor(), enum_t_value);
}
inline bool Position_PositionAccuracy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Position_PositionAccuracy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Position_PositionAccuracy>(
    Position_PositionAccuracy_descriptor(), name, value);
}
enum Voyage_ShipType : int {
  Voyage_ShipType_TYPE__NOT_AVAILABLE = 0,
  Voyage_ShipType_TYPE__RESERVED_1 = 1,
  Voyage_ShipType_TYPE__RESERVED_2 = 2,
  Voyage_ShipType_TYPE__RESERVED_3 = 3,
  Voyage_ShipType_TYPE__RESERVED_4 = 4,
  Voyage_ShipType_TYPE__RESERVED_5 = 5,
  Voyage_ShipType_TYPE__RESERVED_6 = 6,
  Voyage_ShipType_TYPE__RESERVED_7 = 7,
  Voyage_ShipType_TYPE__RESERVED_8 = 8,
  Voyage_ShipType_TYPE__RESERVED_9 = 9,
  Voyage_ShipType_TYPE__RESERVED_10 = 10,
  Voyage_ShipType_TYPE__RESERVED_11 = 11,
  Voyage_ShipType_TYPE__RESERVED_12 = 12,
  Voyage_ShipType_TYPE__RESERVED_13 = 13,
  Voyage_ShipType_TYPE__RESERVED_14 = 14,
  Voyage_ShipType_TYPE__RESERVED_15 = 15,
  Voyage_ShipType_TYPE__RESERVED_16 = 16,
  Voyage_ShipType_TYPE__RESERVED_17 = 17,
  Voyage_ShipType_TYPE__RESERVED_18 = 18,
  Voyage_ShipType_TYPE__RESERVED_19 = 19,
  Voyage_ShipType_TYPE__WING_IN_GROUND = 20,
  Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_A = 21,
  Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_B = 22,
  Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_C = 23,
  Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_D = 24,
  Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_25 = 25,
  Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_26 = 26,
  Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_27 = 27,
  Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_28 = 28,
  Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_29 = 29,
  Voyage_ShipType_TYPE__FISHING = 30,
  Voyage_ShipType_TYPE__TOWING = 31,
  Voyage_ShipType_TYPE__TOWING_LENGTH_EXCEEDS_200M_OR_BREADTH_EXCEEDS_25M = 32,
  Voyage_ShipType_TYPE__DREDGING_OR_UNDERWATER_OPS = 33,
  Voyage_ShipType_TYPE__DIVING_OPS = 34,
  Voyage_ShipType_TYPE__MILITARY_OPS = 35,
  Voyage_ShipType_TYPE__SAILING = 36,
  Voyage_ShipType_TYPE__PLEASURE_CRAFT = 37,
  Voyage_ShipType_TYPE__RESERVED_38 = 38,
  Voyage_ShipType_TYPE__RESERVED_39 = 39,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT = 40,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_A = 41,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_B = 42,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_C = 43,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_D = 44,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_45 = 45,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_46 = 46,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_47 = 47,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_48 = 48,
  Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_NO_ADDITIONAL_INFORMATION = 49,
  Voyage_ShipType_TYPE__PILOT_VESSEL = 50,
  Voyage_ShipType_TYPE__SEARCH_AND_RESCUE_VESSEL = 51,
  Voyage_ShipType_TYPE__TUG = 52,
  Voyage_ShipType_TYPE__PORT_TENDER = 53,
  Voyage_ShipType_TYPE__ANTI_POLLUTION_EQUIPMENT = 54,
  Voyage_ShipType_TYPE__LAW_ENFORCEMENT = 55,
  Voyage_ShipType_TYPE__SPARE56_LOCAL_VESSEL = 56,
  Voyage_ShipType_TYPE__SPARE57_LOCAL_VESSEL = 57,
  Voyage_ShipType_TYPE__MEDICAL_TRANSPORT = 58,
  Voyage_ShipType_TYPE__NONCOMBATANT_SHIP_ACCORDING_TO_RR_RESOLUTION_NO_18 = 59,
  Voyage_ShipType_TYPE__PASSENGER = 60,
  Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_A = 61,
  Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_B = 62,
  Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_C = 63,
  Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_D = 64,
  Voyage_ShipType_TYPE__PASSENGER_RESERVED_65 = 65,
  Voyage_ShipType_TYPE__PASSENGER_RESERVED_66 = 66,
  Voyage_ShipType_TYPE__PASSENGER_RESERVED_67 = 67,
  Voyage_ShipType_TYPE__PASSENGER_RESERVED_68 = 68,
  Voyage_ShipType_TYPE__PASSENGER_NO_ADDITIONAL_INFORMATION = 69,
  Voyage_ShipType_TYPE__CARGO = 70,
  Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_A = 71,
  Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_B = 72,
  Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_C = 73,
  Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_D = 74,
  Voyage_ShipType_TYPE__CARGO_RESERVED_65 = 75,
  Voyage_ShipType_TYPE__CARGO_RESERVED_66 = 76,
  Voyage_ShipType_TYPE__CARGO_RESERVED_67 = 77,
  Voyage_ShipType_TYPE__CARGO_RESERVED_68 = 78,
  Voyage_ShipType_TYPE__CARGO_NO_ADDITIONAL_INFORMATION = 79,
  Voyage_ShipType_TYPE__TANKER = 80,
  Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_A = 81,
  Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_B = 82,
  Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_C = 83,
  Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_D = 84,
  Voyage_ShipType_TYPE__TANKER_RESERVED_65 = 85,
  Voyage_ShipType_TYPE__TANKER_RESERVED_66 = 86,
  Voyage_ShipType_TYPE__TANKER_RESERVED_67 = 87,
  Voyage_ShipType_TYPE__TANKER_RESERVED_68 = 88,
  Voyage_ShipType_TYPE__TANKER_NO_ADDITIONAL_INFORMATION = 89,
  Voyage_ShipType_TYPE__OTHER = 90,
  Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_A = 91,
  Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_B = 92,
  Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_C = 93,
  Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_D = 94,
  Voyage_ShipType_TYPE__OTHER_RESERVED_65 = 95,
  Voyage_ShipType_TYPE__OTHER_RESERVED_66 = 96,
  Voyage_ShipType_TYPE__OTHER_RESERVED_67 = 97,
  Voyage_ShipType_TYPE__OTHER_RESERVED_68 = 98,
  Voyage_ShipType_TYPE__OTHER_NO_ADDITIONAL_INFORMATION = 99
};
bool Voyage_ShipType_IsValid(int value);
constexpr Voyage_ShipType Voyage_ShipType_ShipType_MIN = Voyage_ShipType_TYPE__NOT_AVAILABLE;
constexpr Voyage_ShipType Voyage_ShipType_ShipType_MAX = Voyage_ShipType_TYPE__OTHER_NO_ADDITIONAL_INFORMATION;
constexpr int Voyage_ShipType_ShipType_ARRAYSIZE = Voyage_ShipType_ShipType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Voyage_ShipType_descriptor();
template<typename T>
inline const std::string& Voyage_ShipType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Voyage_ShipType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Voyage_ShipType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Voyage_ShipType_descriptor(), enum_t_value);
}
inline bool Voyage_ShipType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Voyage_ShipType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Voyage_ShipType>(
    Voyage_ShipType_descriptor(), name, value);
}
enum Voyage_FixType : int {
  Voyage_FixType_FIX__UNDEFINED = 0,
  Voyage_FixType_FIX__GPS = 1,
  Voyage_FixType_FIX__GLONASS = 2,
  Voyage_FixType_FIX__COMBINED_GPS_AND_GLONASS = 3,
  Voyage_FixType_FIX__LORAN_C = 4,
  Voyage_FixType_FIX__CHAYKA = 5,
  Voyage_FixType_FIX__INTEGRATED_NAVIGATION_SYSTEM = 6,
  Voyage_FixType_FIX__SURVEYED = 7,
  Voyage_FixType_FIX__GALILEO = 8
};
bool Voyage_FixType_IsValid(int value);
constexpr Voyage_FixType Voyage_FixType_FixType_MIN = Voyage_FixType_FIX__UNDEFINED;
constexpr Voyage_FixType Voyage_FixType_FixType_MAX = Voyage_FixType_FIX__GALILEO;
constexpr int Voyage_FixType_FixType_ARRAYSIZE = Voyage_FixType_FixType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Voyage_FixType_descriptor();
template<typename T>
inline const std::string& Voyage_FixType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Voyage_FixType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Voyage_FixType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Voyage_FixType_descriptor(), enum_t_value);
}
inline bool Voyage_FixType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Voyage_FixType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Voyage_FixType>(
    Voyage_FixType_descriptor(), name, value);
}
enum Status : int {
  AIS_STATUS__UNDER_WAY_USING_ENGINE = 0,
  AIS_STATUS__AT_ANCHOR = 1,
  AIS_STATUS__NOT_UNDER_COMMAND = 2,
  AIS_STATUS__RESTRICTED_MANOEUVERABILITY = 3,
  AIS_STATUS__CONSTRAINED_BY_HER_DRAUGHT = 4,
  AIS_STATUS__MOORED = 5,
  AIS_STATUS__AGROUND = 6,
  AIS_STATUS__ENGAGED_IN_FISHING = 7,
  AIS_STATUS__UNDER_WAY_SAILING = 8,
  AIS_STATUS__RESERVED_FOR_HIGH_SPEED_CRAFT = 9,
  AIS_STATUS__RESERVED_FOR_WING_IN_GROUND = 10,
  AIS_STATUS__RESERVED_11 = 11,
  AIS_STATUS__RESERVED_12 = 12,
  AIS_STATUS__RESERVED_13 = 13,
  AIS_STATUS__SART_IS_ACTIVE = 14,
  AIS_STATUS__NOT_DEFINED = 15
};
bool Status_IsValid(int value);
constexpr Status Status_MIN = AIS_STATUS__UNDER_WAY_USING_ENGINE;
constexpr Status Status_MAX = AIS_STATUS__NOT_DEFINED;
constexpr int Status_ARRAYSIZE = Status_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Status_descriptor();
template<typename T>
inline const std::string& Status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Status_descriptor(), enum_t_value);
}
inline bool Status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Status>(
    Status_descriptor(), name, value);
}
// ===================================================================
 
class Position final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.util.ais.protobuf.Position) */ {
 public:
  inline Position() : Position(nullptr) {}
  ~Position() override;
  explicit PROTOBUF_CONSTEXPR Position(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Position(const Position& from);
  Position(Position&& from) noexcept
    : Position() {
    *this = ::std::move(from);
  }
 
  inline Position& operator=(const Position& from) {
    CopyFrom(from);
    return *this;
  }
  inline Position& operator=(Position&& 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 Position& default_instance() {
    return *internal_default_instance();
  }
  static inline const Position* internal_default_instance() {
    return reinterpret_cast<const Position*>(
               &_Position_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(Position& a, Position& b) {
    a.Swap(&b);
  }
  inline void Swap(Position* 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(Position* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Position* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Position>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Position& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Position& from) {
    Position::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(Position* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.util.ais.protobuf.Position";
  }
  protected:
  explicit Position(::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 Position_TurnInfo TurnInfo;
  static constexpr TurnInfo TURN_INFO__NOT_TURNING =
    Position_TurnInfo_TURN_INFO__NOT_TURNING;
  static constexpr TurnInfo TURN_INFO__TURNING_AT_GIVEN_RATE =
    Position_TurnInfo_TURN_INFO__TURNING_AT_GIVEN_RATE;
  static constexpr TurnInfo TURN_INFO__TURNING_RIGHT_AT_MORE_THAN_5_DEG_PER_30_SEC =
    Position_TurnInfo_TURN_INFO__TURNING_RIGHT_AT_MORE_THAN_5_DEG_PER_30_SEC;
  static constexpr TurnInfo TURN_INFO__TURNING_LEFT_AT_MORE_THAN_5_DEG_PER_30_SEC =
    Position_TurnInfo_TURN_INFO__TURNING_LEFT_AT_MORE_THAN_5_DEG_PER_30_SEC;
  static constexpr TurnInfo TURN_INFO__NO_TURN_INFORMATION =
    Position_TurnInfo_TURN_INFO__NO_TURN_INFORMATION;
  static inline bool TurnInfo_IsValid(int value) {
    return Position_TurnInfo_IsValid(value);
  }
  static constexpr TurnInfo TurnInfo_MIN =
    Position_TurnInfo_TurnInfo_MIN;
  static constexpr TurnInfo TurnInfo_MAX =
    Position_TurnInfo_TurnInfo_MAX;
  static constexpr int TurnInfo_ARRAYSIZE =
    Position_TurnInfo_TurnInfo_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  TurnInfo_descriptor() {
    return Position_TurnInfo_descriptor();
  }
  template<typename T>
  static inline const std::string& TurnInfo_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TurnInfo>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TurnInfo_Name.");
    return Position_TurnInfo_Name(enum_t_value);
  }
  static inline bool TurnInfo_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TurnInfo* value) {
    return Position_TurnInfo_Parse(name, value);
  }
 
  typedef Position_PositionAccuracy PositionAccuracy;
  static constexpr PositionAccuracy ACCURACY__LOW__ABOVE_10_METERS =
    Position_PositionAccuracy_ACCURACY__LOW__ABOVE_10_METERS;
  static constexpr PositionAccuracy ACCURACY__HIGH__BELOW_10_METERS =
    Position_PositionAccuracy_ACCURACY__HIGH__BELOW_10_METERS;
  static inline bool PositionAccuracy_IsValid(int value) {
    return Position_PositionAccuracy_IsValid(value);
  }
  static constexpr PositionAccuracy PositionAccuracy_MIN =
    Position_PositionAccuracy_PositionAccuracy_MIN;
  static constexpr PositionAccuracy PositionAccuracy_MAX =
    Position_PositionAccuracy_PositionAccuracy_MAX;
  static constexpr int PositionAccuracy_ARRAYSIZE =
    Position_PositionAccuracy_PositionAccuracy_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PositionAccuracy_descriptor() {
    return Position_PositionAccuracy_descriptor();
  }
  template<typename T>
  static inline const std::string& PositionAccuracy_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PositionAccuracy>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PositionAccuracy_Name.");
    return Position_PositionAccuracy_Name(enum_t_value);
  }
  static inline bool PositionAccuracy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PositionAccuracy* value) {
    return Position_PositionAccuracy_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kMessageIdFieldNumber = 2,
    kMmsiFieldNumber = 3,
    kTurnRateFieldNumber = 6,
    kSpeedOverGroundFieldNumber = 7,
    kLatFieldNumber = 9,
    kPositionAccuracyFieldNumber = 8,
    kCourseOverGroundFieldNumber = 11,
    kLonFieldNumber = 10,
    kTrueHeadingFieldNumber = 12,
    kReportSecondFieldNumber = 13,
    kRaimFieldNumber = 14,
    kNavStatusFieldNumber = 4,
    kTurnInfoFieldNumber = 5,
  };
  // optional int32 message_id = 2 [default = 0, (.dccl.field) = {
  bool has_message_id() const;
  private:
  bool _internal_has_message_id() const;
  public:
  void clear_message_id();
  int32_t message_id() const;
  void set_message_id(int32_t value);
  private:
  int32_t _internal_message_id() const;
  void _internal_set_message_id(int32_t value);
  public:
 
  // optional int32 mmsi = 3 [(.dccl.field) = {
  bool has_mmsi() const;
  private:
  bool _internal_has_mmsi() const;
  public:
  void clear_mmsi();
  int32_t mmsi() const;
  void set_mmsi(int32_t value);
  private:
  int32_t _internal_mmsi() const;
  void _internal_set_mmsi(int32_t value);
  public:
 
  // optional float turn_rate = 6 [(.dccl.field) = {
  bool has_turn_rate() const;
  private:
  bool _internal_has_turn_rate() const;
  public:
  void clear_turn_rate();
  float turn_rate() const;
  void set_turn_rate(float value);
  private:
  float _internal_turn_rate() const;
  void _internal_set_turn_rate(float value);
  public:
 
  // optional float speed_over_ground = 7 [(.dccl.field) = {
  bool has_speed_over_ground() const;
  private:
  bool _internal_has_speed_over_ground() const;
  public:
  void clear_speed_over_ground();
  float speed_over_ground() const;
  void set_speed_over_ground(float value);
  private:
  float _internal_speed_over_ground() const;
  void _internal_set_speed_over_ground(float value);
  public:
 
  // optional double lat = 9 [(.dccl.field) = {
  bool has_lat() const;
  private:
  bool _internal_has_lat() const;
  public:
  void clear_lat();
  double lat() const;
  void set_lat(double value);
  private:
  double _internal_lat() const;
  void _internal_set_lat(double value);
  public:
 
  // optional .goby.util.ais.protobuf.Position.PositionAccuracy position_accuracy = 8 [default = ACCURACY__LOW__ABOVE_10_METERS];
  bool has_position_accuracy() const;
  private:
  bool _internal_has_position_accuracy() const;
  public:
  void clear_position_accuracy();
  ::goby::util::ais::protobuf::Position_PositionAccuracy position_accuracy() const;
  void set_position_accuracy(::goby::util::ais::protobuf::Position_PositionAccuracy value);
  private:
  ::goby::util::ais::protobuf::Position_PositionAccuracy _internal_position_accuracy() const;
  void _internal_set_position_accuracy(::goby::util::ais::protobuf::Position_PositionAccuracy value);
  public:
 
  // optional float course_over_ground = 11 [(.dccl.field) = {
  bool has_course_over_ground() const;
  private:
  bool _internal_has_course_over_ground() const;
  public:
  void clear_course_over_ground();
  float course_over_ground() const;
  void set_course_over_ground(float value);
  private:
  float _internal_course_over_ground() const;
  void _internal_set_course_over_ground(float value);
  public:
 
  // optional double lon = 10 [(.dccl.field) = {
  bool has_lon() const;
  private:
  bool _internal_has_lon() const;
  public:
  void clear_lon();
  double lon() const;
  void set_lon(double value);
  private:
  double _internal_lon() const;
  void _internal_set_lon(double value);
  public:
 
  // optional float true_heading = 12 [(.dccl.field) = {
  bool has_true_heading() const;
  private:
  bool _internal_has_true_heading() const;
  public:
  void clear_true_heading();
  float true_heading() const;
  void set_true_heading(float value);
  private:
  float _internal_true_heading() const;
  void _internal_set_true_heading(float value);
  public:
 
  // optional int32 report_second = 13 [(.dccl.field) = {
  bool has_report_second() const;
  private:
  bool _internal_has_report_second() const;
  public:
  void clear_report_second();
  int32_t report_second() const;
  void set_report_second(int32_t value);
  private:
  int32_t _internal_report_second() const;
  void _internal_set_report_second(int32_t value);
  public:
 
  // optional bool raim = 14 [(.dccl.field) = {
  bool has_raim() const;
  private:
  bool _internal_has_raim() const;
  public:
  void clear_raim();
  bool raim() const;
  void set_raim(bool value);
  private:
  bool _internal_raim() const;
  void _internal_set_raim(bool value);
  public:
 
  // optional .goby.util.ais.protobuf.Status nav_status = 4 [default = AIS_STATUS__NOT_DEFINED];
  bool has_nav_status() const;
  private:
  bool _internal_has_nav_status() const;
  public:
  void clear_nav_status();
  ::goby::util::ais::protobuf::Status nav_status() const;
  void set_nav_status(::goby::util::ais::protobuf::Status value);
  private:
  ::goby::util::ais::protobuf::Status _internal_nav_status() const;
  void _internal_set_nav_status(::goby::util::ais::protobuf::Status value);
  public:
 
  // optional .goby.util.ais.protobuf.Position.TurnInfo turn_info = 5 [default = TURN_INFO__NO_TURN_INFORMATION];
  bool has_turn_info() const;
  private:
  bool _internal_has_turn_info() const;
  public:
  void clear_turn_info();
  ::goby::util::ais::protobuf::Position_TurnInfo turn_info() const;
  void set_turn_info(::goby::util::ais::protobuf::Position_TurnInfo value);
  private:
  ::goby::util::ais::protobuf::Position_TurnInfo _internal_turn_info() const;
  void _internal_set_turn_info(::goby::util::ais::protobuf::Position_TurnInfo value);
  public:
 
  enum DCCLParameters { DCCL_ID = 518,  DCCL_MAX_BYTES = 1500 };
  typedef boost::units::angular_velocity_dimension turn_rate_dimension;
  
  typedef boost::units::unit<turn_rate_dimension,boost::units::si::system> turn_rate_unit;
  
  template<typename Quantity >
    void set_turn_rate_with_units(Quantity value_w_units)
    { set_turn_rate(boost::units::quantity<turn_rate_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity turn_rate_with_units() const
    { return Quantity(turn_rate() * turn_rate_unit()); };
  
  boost::units::quantity< turn_rate_unit,float > turn_rate_with_units() const
    { return turn_rate_with_units<boost::units::quantity< turn_rate_unit,float > >(); };
  
  typedef boost::units::velocity_dimension speed_over_ground_dimension;
  
  typedef boost::units::unit<speed_over_ground_dimension,boost::units::si::system> speed_over_ground_unit;
  
  template<typename Quantity >
    void set_speed_over_ground_with_units(Quantity value_w_units)
    { set_speed_over_ground(boost::units::quantity<speed_over_ground_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity speed_over_ground_with_units() const
    { return Quantity(speed_over_ground() * speed_over_ground_unit()); };
  
  boost::units::quantity< speed_over_ground_unit,float > speed_over_ground_with_units() const
    { return speed_over_ground_with_units<boost::units::quantity< speed_over_ground_unit,float > >(); };
  
  typedef boost::units::plane_angle_dimension lat_dimension;
  
  typedef boost::units::unit<lat_dimension,boost::units::degree::system> lat_unit;
  
  template<typename Quantity >
    void set_lat_with_units(Quantity value_w_units)
    { set_lat(boost::units::quantity<lat_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity lat_with_units() const
    { return Quantity(lat() * lat_unit()); };
  
  boost::units::quantity< lat_unit,double > lat_with_units() const
    { return lat_with_units<boost::units::quantity< lat_unit,double > >(); };
  
  typedef boost::units::plane_angle_dimension lon_dimension;
  
  typedef boost::units::unit<lon_dimension,boost::units::degree::system> lon_unit;
  
  template<typename Quantity >
    void set_lon_with_units(Quantity value_w_units)
    { set_lon(boost::units::quantity<lon_unit,double >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity lon_with_units() const
    { return Quantity(lon() * lon_unit()); };
  
  boost::units::quantity< lon_unit,double > lon_with_units() const
    { return lon_with_units<boost::units::quantity< lon_unit,double > >(); };
  
  typedef boost::units::plane_angle_dimension course_over_ground_dimension;
  
  typedef boost::units::unit<course_over_ground_dimension,boost::units::degree::system> course_over_ground_unit;
  
  template<typename Quantity >
    void set_course_over_ground_with_units(Quantity value_w_units)
    { set_course_over_ground(boost::units::quantity<course_over_ground_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity course_over_ground_with_units() const
    { return Quantity(course_over_ground() * course_over_ground_unit()); };
  
  boost::units::quantity< course_over_ground_unit,float > course_over_ground_with_units() const
    { return course_over_ground_with_units<boost::units::quantity< course_over_ground_unit,float > >(); };
  
  typedef boost::units::plane_angle_dimension true_heading_dimension;
  
  typedef boost::units::unit<true_heading_dimension,boost::units::degree::system> true_heading_unit;
  
  template<typename Quantity >
    void set_true_heading_with_units(Quantity value_w_units)
    { set_true_heading(boost::units::quantity<true_heading_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity true_heading_with_units() const
    { return Quantity(true_heading() * true_heading_unit()); };
  
  boost::units::quantity< true_heading_unit,float > true_heading_with_units() const
    { return true_heading_with_units<boost::units::quantity< true_heading_unit,float > >(); };
  
  typedef boost::units::time_dimension report_second_dimension;
  
  typedef boost::units::unit<report_second_dimension,boost::units::si::system> report_second_unit;
  
  template<typename Quantity >
    void set_report_second_with_units(Quantity value_w_units)
    { set_report_second(boost::units::quantity<report_second_unit,google::protobuf::int32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity report_second_with_units() const
    { return Quantity(report_second() * report_second_unit()); };
  
  boost::units::quantity< report_second_unit,google::protobuf::int32 > report_second_with_units() const
    { return report_second_with_units<boost::units::quantity< report_second_unit,google::protobuf::int32 > >(); };
  
  // @@protoc_insertion_point(class_scope:goby.util.ais.protobuf.Position)
 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 message_id_;
    int32_t mmsi_;
    float turn_rate_;
    float speed_over_ground_;
    double lat_;
    int position_accuracy_;
    float course_over_ground_;
    double lon_;
    float true_heading_;
    int32_t report_second_;
    bool raim_;
    int nav_status_;
    int turn_info_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2futil_2fprotobuf_2fais_2eproto;
};
// -------------------------------------------------------------------
 
class Voyage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:goby.util.ais.protobuf.Voyage) */ {
 public:
  inline Voyage() : Voyage(nullptr) {}
  ~Voyage() override;
  explicit PROTOBUF_CONSTEXPR Voyage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  Voyage(const Voyage& from);
  Voyage(Voyage&& from) noexcept
    : Voyage() {
    *this = ::std::move(from);
  }
 
  inline Voyage& operator=(const Voyage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Voyage& operator=(Voyage&& 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 Voyage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Voyage* internal_default_instance() {
    return reinterpret_cast<const Voyage*>(
               &_Voyage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;
 
  friend void swap(Voyage& a, Voyage& b) {
    a.Swap(&b);
  }
  inline void Swap(Voyage* 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(Voyage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  Voyage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Voyage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Voyage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Voyage& from) {
    Voyage::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(Voyage* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "goby.util.ais.protobuf.Voyage";
  }
  protected:
  explicit Voyage(::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 Voyage_ShipType ShipType;
  static constexpr ShipType TYPE__NOT_AVAILABLE =
    Voyage_ShipType_TYPE__NOT_AVAILABLE;
  static constexpr ShipType TYPE__RESERVED_1 =
    Voyage_ShipType_TYPE__RESERVED_1;
  static constexpr ShipType TYPE__RESERVED_2 =
    Voyage_ShipType_TYPE__RESERVED_2;
  static constexpr ShipType TYPE__RESERVED_3 =
    Voyage_ShipType_TYPE__RESERVED_3;
  static constexpr ShipType TYPE__RESERVED_4 =
    Voyage_ShipType_TYPE__RESERVED_4;
  static constexpr ShipType TYPE__RESERVED_5 =
    Voyage_ShipType_TYPE__RESERVED_5;
  static constexpr ShipType TYPE__RESERVED_6 =
    Voyage_ShipType_TYPE__RESERVED_6;
  static constexpr ShipType TYPE__RESERVED_7 =
    Voyage_ShipType_TYPE__RESERVED_7;
  static constexpr ShipType TYPE__RESERVED_8 =
    Voyage_ShipType_TYPE__RESERVED_8;
  static constexpr ShipType TYPE__RESERVED_9 =
    Voyage_ShipType_TYPE__RESERVED_9;
  static constexpr ShipType TYPE__RESERVED_10 =
    Voyage_ShipType_TYPE__RESERVED_10;
  static constexpr ShipType TYPE__RESERVED_11 =
    Voyage_ShipType_TYPE__RESERVED_11;
  static constexpr ShipType TYPE__RESERVED_12 =
    Voyage_ShipType_TYPE__RESERVED_12;
  static constexpr ShipType TYPE__RESERVED_13 =
    Voyage_ShipType_TYPE__RESERVED_13;
  static constexpr ShipType TYPE__RESERVED_14 =
    Voyage_ShipType_TYPE__RESERVED_14;
  static constexpr ShipType TYPE__RESERVED_15 =
    Voyage_ShipType_TYPE__RESERVED_15;
  static constexpr ShipType TYPE__RESERVED_16 =
    Voyage_ShipType_TYPE__RESERVED_16;
  static constexpr ShipType TYPE__RESERVED_17 =
    Voyage_ShipType_TYPE__RESERVED_17;
  static constexpr ShipType TYPE__RESERVED_18 =
    Voyage_ShipType_TYPE__RESERVED_18;
  static constexpr ShipType TYPE__RESERVED_19 =
    Voyage_ShipType_TYPE__RESERVED_19;
  static constexpr ShipType TYPE__WING_IN_GROUND =
    Voyage_ShipType_TYPE__WING_IN_GROUND;
  static constexpr ShipType TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__WING_IN_GROUND_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__WING_IN_GROUND_RESERVED_25 =
    Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_25;
  static constexpr ShipType TYPE__WING_IN_GROUND_RESERVED_26 =
    Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_26;
  static constexpr ShipType TYPE__WING_IN_GROUND_RESERVED_27 =
    Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_27;
  static constexpr ShipType TYPE__WING_IN_GROUND_RESERVED_28 =
    Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_28;
  static constexpr ShipType TYPE__WING_IN_GROUND_RESERVED_29 =
    Voyage_ShipType_TYPE__WING_IN_GROUND_RESERVED_29;
  static constexpr ShipType TYPE__FISHING =
    Voyage_ShipType_TYPE__FISHING;
  static constexpr ShipType TYPE__TOWING =
    Voyage_ShipType_TYPE__TOWING;
  static constexpr ShipType TYPE__TOWING_LENGTH_EXCEEDS_200M_OR_BREADTH_EXCEEDS_25M =
    Voyage_ShipType_TYPE__TOWING_LENGTH_EXCEEDS_200M_OR_BREADTH_EXCEEDS_25M;
  static constexpr ShipType TYPE__DREDGING_OR_UNDERWATER_OPS =
    Voyage_ShipType_TYPE__DREDGING_OR_UNDERWATER_OPS;
  static constexpr ShipType TYPE__DIVING_OPS =
    Voyage_ShipType_TYPE__DIVING_OPS;
  static constexpr ShipType TYPE__MILITARY_OPS =
    Voyage_ShipType_TYPE__MILITARY_OPS;
  static constexpr ShipType TYPE__SAILING =
    Voyage_ShipType_TYPE__SAILING;
  static constexpr ShipType TYPE__PLEASURE_CRAFT =
    Voyage_ShipType_TYPE__PLEASURE_CRAFT;
  static constexpr ShipType TYPE__RESERVED_38 =
    Voyage_ShipType_TYPE__RESERVED_38;
  static constexpr ShipType TYPE__RESERVED_39 =
    Voyage_ShipType_TYPE__RESERVED_39;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_RESERVED_45 =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_45;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_RESERVED_46 =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_46;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_RESERVED_47 =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_47;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_RESERVED_48 =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_RESERVED_48;
  static constexpr ShipType TYPE__HIGH_SPEED_CRAFT_NO_ADDITIONAL_INFORMATION =
    Voyage_ShipType_TYPE__HIGH_SPEED_CRAFT_NO_ADDITIONAL_INFORMATION;
  static constexpr ShipType TYPE__PILOT_VESSEL =
    Voyage_ShipType_TYPE__PILOT_VESSEL;
  static constexpr ShipType TYPE__SEARCH_AND_RESCUE_VESSEL =
    Voyage_ShipType_TYPE__SEARCH_AND_RESCUE_VESSEL;
  static constexpr ShipType TYPE__TUG =
    Voyage_ShipType_TYPE__TUG;
  static constexpr ShipType TYPE__PORT_TENDER =
    Voyage_ShipType_TYPE__PORT_TENDER;
  static constexpr ShipType TYPE__ANTI_POLLUTION_EQUIPMENT =
    Voyage_ShipType_TYPE__ANTI_POLLUTION_EQUIPMENT;
  static constexpr ShipType TYPE__LAW_ENFORCEMENT =
    Voyage_ShipType_TYPE__LAW_ENFORCEMENT;
  static constexpr ShipType TYPE__SPARE56_LOCAL_VESSEL =
    Voyage_ShipType_TYPE__SPARE56_LOCAL_VESSEL;
  static constexpr ShipType TYPE__SPARE57_LOCAL_VESSEL =
    Voyage_ShipType_TYPE__SPARE57_LOCAL_VESSEL;
  static constexpr ShipType TYPE__MEDICAL_TRANSPORT =
    Voyage_ShipType_TYPE__MEDICAL_TRANSPORT;
  static constexpr ShipType TYPE__NONCOMBATANT_SHIP_ACCORDING_TO_RR_RESOLUTION_NO_18 =
    Voyage_ShipType_TYPE__NONCOMBATANT_SHIP_ACCORDING_TO_RR_RESOLUTION_NO_18;
  static constexpr ShipType TYPE__PASSENGER =
    Voyage_ShipType_TYPE__PASSENGER;
  static constexpr ShipType TYPE__PASSENGER_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__PASSENGER_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__PASSENGER_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__PASSENGER_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__PASSENGER_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__PASSENGER_RESERVED_65 =
    Voyage_ShipType_TYPE__PASSENGER_RESERVED_65;
  static constexpr ShipType TYPE__PASSENGER_RESERVED_66 =
    Voyage_ShipType_TYPE__PASSENGER_RESERVED_66;
  static constexpr ShipType TYPE__PASSENGER_RESERVED_67 =
    Voyage_ShipType_TYPE__PASSENGER_RESERVED_67;
  static constexpr ShipType TYPE__PASSENGER_RESERVED_68 =
    Voyage_ShipType_TYPE__PASSENGER_RESERVED_68;
  static constexpr ShipType TYPE__PASSENGER_NO_ADDITIONAL_INFORMATION =
    Voyage_ShipType_TYPE__PASSENGER_NO_ADDITIONAL_INFORMATION;
  static constexpr ShipType TYPE__CARGO =
    Voyage_ShipType_TYPE__CARGO;
  static constexpr ShipType TYPE__CARGO_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__CARGO_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__CARGO_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__CARGO_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__CARGO_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__CARGO_RESERVED_65 =
    Voyage_ShipType_TYPE__CARGO_RESERVED_65;
  static constexpr ShipType TYPE__CARGO_RESERVED_66 =
    Voyage_ShipType_TYPE__CARGO_RESERVED_66;
  static constexpr ShipType TYPE__CARGO_RESERVED_67 =
    Voyage_ShipType_TYPE__CARGO_RESERVED_67;
  static constexpr ShipType TYPE__CARGO_RESERVED_68 =
    Voyage_ShipType_TYPE__CARGO_RESERVED_68;
  static constexpr ShipType TYPE__CARGO_NO_ADDITIONAL_INFORMATION =
    Voyage_ShipType_TYPE__CARGO_NO_ADDITIONAL_INFORMATION;
  static constexpr ShipType TYPE__TANKER =
    Voyage_ShipType_TYPE__TANKER;
  static constexpr ShipType TYPE__TANKER_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__TANKER_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__TANKER_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__TANKER_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__TANKER_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__TANKER_RESERVED_65 =
    Voyage_ShipType_TYPE__TANKER_RESERVED_65;
  static constexpr ShipType TYPE__TANKER_RESERVED_66 =
    Voyage_ShipType_TYPE__TANKER_RESERVED_66;
  static constexpr ShipType TYPE__TANKER_RESERVED_67 =
    Voyage_ShipType_TYPE__TANKER_RESERVED_67;
  static constexpr ShipType TYPE__TANKER_RESERVED_68 =
    Voyage_ShipType_TYPE__TANKER_RESERVED_68;
  static constexpr ShipType TYPE__TANKER_NO_ADDITIONAL_INFORMATION =
    Voyage_ShipType_TYPE__TANKER_NO_ADDITIONAL_INFORMATION;
  static constexpr ShipType TYPE__OTHER =
    Voyage_ShipType_TYPE__OTHER;
  static constexpr ShipType TYPE__OTHER_HAZARDOUS_CATEGORY_A =
    Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_A;
  static constexpr ShipType TYPE__OTHER_HAZARDOUS_CATEGORY_B =
    Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_B;
  static constexpr ShipType TYPE__OTHER_HAZARDOUS_CATEGORY_C =
    Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_C;
  static constexpr ShipType TYPE__OTHER_HAZARDOUS_CATEGORY_D =
    Voyage_ShipType_TYPE__OTHER_HAZARDOUS_CATEGORY_D;
  static constexpr ShipType TYPE__OTHER_RESERVED_65 =
    Voyage_ShipType_TYPE__OTHER_RESERVED_65;
  static constexpr ShipType TYPE__OTHER_RESERVED_66 =
    Voyage_ShipType_TYPE__OTHER_RESERVED_66;
  static constexpr ShipType TYPE__OTHER_RESERVED_67 =
    Voyage_ShipType_TYPE__OTHER_RESERVED_67;
  static constexpr ShipType TYPE__OTHER_RESERVED_68 =
    Voyage_ShipType_TYPE__OTHER_RESERVED_68;
  static constexpr ShipType TYPE__OTHER_NO_ADDITIONAL_INFORMATION =
    Voyage_ShipType_TYPE__OTHER_NO_ADDITIONAL_INFORMATION;
  static inline bool ShipType_IsValid(int value) {
    return Voyage_ShipType_IsValid(value);
  }
  static constexpr ShipType ShipType_MIN =
    Voyage_ShipType_ShipType_MIN;
  static constexpr ShipType ShipType_MAX =
    Voyage_ShipType_ShipType_MAX;
  static constexpr int ShipType_ARRAYSIZE =
    Voyage_ShipType_ShipType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ShipType_descriptor() {
    return Voyage_ShipType_descriptor();
  }
  template<typename T>
  static inline const std::string& ShipType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ShipType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ShipType_Name.");
    return Voyage_ShipType_Name(enum_t_value);
  }
  static inline bool ShipType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ShipType* value) {
    return Voyage_ShipType_Parse(name, value);
  }
 
  typedef Voyage_FixType FixType;
  static constexpr FixType FIX__UNDEFINED =
    Voyage_FixType_FIX__UNDEFINED;
  static constexpr FixType FIX__GPS =
    Voyage_FixType_FIX__GPS;
  static constexpr FixType FIX__GLONASS =
    Voyage_FixType_FIX__GLONASS;
  static constexpr FixType FIX__COMBINED_GPS_AND_GLONASS =
    Voyage_FixType_FIX__COMBINED_GPS_AND_GLONASS;
  static constexpr FixType FIX__LORAN_C =
    Voyage_FixType_FIX__LORAN_C;
  static constexpr FixType FIX__CHAYKA =
    Voyage_FixType_FIX__CHAYKA;
  static constexpr FixType FIX__INTEGRATED_NAVIGATION_SYSTEM =
    Voyage_FixType_FIX__INTEGRATED_NAVIGATION_SYSTEM;
  static constexpr FixType FIX__SURVEYED =
    Voyage_FixType_FIX__SURVEYED;
  static constexpr FixType FIX__GALILEO =
    Voyage_FixType_FIX__GALILEO;
  static inline bool FixType_IsValid(int value) {
    return Voyage_FixType_IsValid(value);
  }
  static constexpr FixType FixType_MIN =
    Voyage_FixType_FixType_MIN;
  static constexpr FixType FixType_MAX =
    Voyage_FixType_FixType_MAX;
  static constexpr int FixType_ARRAYSIZE =
    Voyage_FixType_FixType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  FixType_descriptor() {
    return Voyage_FixType_descriptor();
  }
  template<typename T>
  static inline const std::string& FixType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FixType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FixType_Name.");
    return Voyage_FixType_Name(enum_t_value);
  }
  static inline bool FixType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FixType* value) {
    return Voyage_FixType_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kCallsignFieldNumber = 5,
    kNameFieldNumber = 6,
    kDestinationFieldNumber = 18,
    kMessageIdFieldNumber = 2,
    kMmsiFieldNumber = 3,
    kImoFieldNumber = 4,
    kTypeFieldNumber = 7,
    kToBowFieldNumber = 8,
    kToSternFieldNumber = 9,
    kToPortFieldNumber = 10,
    kToStarboardFieldNumber = 11,
    kFixTypeFieldNumber = 12,
    kEtaMonthFieldNumber = 13,
    kEtaDayFieldNumber = 14,
    kEtaHourFieldNumber = 15,
    kEtaMinuteFieldNumber = 16,
    kDraughtFieldNumber = 17,
  };
  // optional string callsign = 5 [(.dccl.field) = {
  bool has_callsign() const;
  private:
  bool _internal_has_callsign() const;
  public:
  void clear_callsign();
  const std::string& callsign() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_callsign(ArgT0&& arg0, ArgT... args);
  std::string* mutable_callsign();
  PROTOBUF_NODISCARD std::string* release_callsign();
  void set_allocated_callsign(std::string* callsign);
  private:
  const std::string& _internal_callsign() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callsign(const std::string& value);
  std::string* _internal_mutable_callsign();
  public:
 
  // optional string name = 6 [(.dccl.field) = {
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // optional string destination = 18 [(.dccl.field) = {
  bool has_destination() const;
  private:
  bool _internal_has_destination() const;
  public:
  void clear_destination();
  const std::string& destination() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_destination(ArgT0&& arg0, ArgT... args);
  std::string* mutable_destination();
  PROTOBUF_NODISCARD std::string* release_destination();
  void set_allocated_destination(std::string* destination);
  private:
  const std::string& _internal_destination() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_destination(const std::string& value);
  std::string* _internal_mutable_destination();
  public:
 
  // optional int32 message_id = 2 [default = 0, (.dccl.field) = {
  bool has_message_id() const;
  private:
  bool _internal_has_message_id() const;
  public:
  void clear_message_id();
  int32_t message_id() const;
  void set_message_id(int32_t value);
  private:
  int32_t _internal_message_id() const;
  void _internal_set_message_id(int32_t value);
  public:
 
  // optional int32 mmsi = 3 [(.dccl.field) = {
  bool has_mmsi() const;
  private:
  bool _internal_has_mmsi() const;
  public:
  void clear_mmsi();
  int32_t mmsi() const;
  void set_mmsi(int32_t value);
  private:
  int32_t _internal_mmsi() const;
  void _internal_set_mmsi(int32_t value);
  public:
 
  // optional int32 imo = 4 [(.dccl.field) = {
  bool has_imo() const;
  private:
  bool _internal_has_imo() const;
  public:
  void clear_imo();
  int32_t imo() const;
  void set_imo(int32_t value);
  private:
  int32_t _internal_imo() const;
  void _internal_set_imo(int32_t value);
  public:
 
  // optional .goby.util.ais.protobuf.Voyage.ShipType type = 7 [default = TYPE__NOT_AVAILABLE];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::goby::util::ais::protobuf::Voyage_ShipType type() const;
  void set_type(::goby::util::ais::protobuf::Voyage_ShipType value);
  private:
  ::goby::util::ais::protobuf::Voyage_ShipType _internal_type() const;
  void _internal_set_type(::goby::util::ais::protobuf::Voyage_ShipType value);
  public:
 
  // optional uint32 to_bow = 8 [(.dccl.field) = {
  bool has_to_bow() const;
  private:
  bool _internal_has_to_bow() const;
  public:
  void clear_to_bow();
  uint32_t to_bow() const;
  void set_to_bow(uint32_t value);
  private:
  uint32_t _internal_to_bow() const;
  void _internal_set_to_bow(uint32_t value);
  public:
 
  // optional uint32 to_stern = 9 [(.dccl.field) = {
  bool has_to_stern() const;
  private:
  bool _internal_has_to_stern() const;
  public:
  void clear_to_stern();
  uint32_t to_stern() const;
  void set_to_stern(uint32_t value);
  private:
  uint32_t _internal_to_stern() const;
  void _internal_set_to_stern(uint32_t value);
  public:
 
  // optional uint32 to_port = 10 [(.dccl.field) = {
  bool has_to_port() const;
  private:
  bool _internal_has_to_port() const;
  public:
  void clear_to_port();
  uint32_t to_port() const;
  void set_to_port(uint32_t value);
  private:
  uint32_t _internal_to_port() const;
  void _internal_set_to_port(uint32_t value);
  public:
 
  // optional uint32 to_starboard = 11 [(.dccl.field) = {
  bool has_to_starboard() const;
  private:
  bool _internal_has_to_starboard() const;
  public:
  void clear_to_starboard();
  uint32_t to_starboard() const;
  void set_to_starboard(uint32_t value);
  private:
  uint32_t _internal_to_starboard() const;
  void _internal_set_to_starboard(uint32_t value);
  public:
 
  // optional .goby.util.ais.protobuf.Voyage.FixType fix_type = 12 [default = FIX__UNDEFINED];
  bool has_fix_type() const;
  private:
  bool _internal_has_fix_type() const;
  public:
  void clear_fix_type();
  ::goby::util::ais::protobuf::Voyage_FixType fix_type() const;
  void set_fix_type(::goby::util::ais::protobuf::Voyage_FixType value);
  private:
  ::goby::util::ais::protobuf::Voyage_FixType _internal_fix_type() const;
  void _internal_set_fix_type(::goby::util::ais::protobuf::Voyage_FixType value);
  public:
 
  // optional uint32 eta_month = 13 [(.dccl.field) = {
  bool has_eta_month() const;
  private:
  bool _internal_has_eta_month() const;
  public:
  void clear_eta_month();
  uint32_t eta_month() const;
  void set_eta_month(uint32_t value);
  private:
  uint32_t _internal_eta_month() const;
  void _internal_set_eta_month(uint32_t value);
  public:
 
  // optional uint32 eta_day = 14 [(.dccl.field) = {
  bool has_eta_day() const;
  private:
  bool _internal_has_eta_day() const;
  public:
  void clear_eta_day();
  uint32_t eta_day() const;
  void set_eta_day(uint32_t value);
  private:
  uint32_t _internal_eta_day() const;
  void _internal_set_eta_day(uint32_t value);
  public:
 
  // optional uint32 eta_hour = 15 [(.dccl.field) = {
  bool has_eta_hour() const;
  private:
  bool _internal_has_eta_hour() const;
  public:
  void clear_eta_hour();
  uint32_t eta_hour() const;
  void set_eta_hour(uint32_t value);
  private:
  uint32_t _internal_eta_hour() const;
  void _internal_set_eta_hour(uint32_t value);
  public:
 
  // optional uint32 eta_minute = 16 [(.dccl.field) = {
  bool has_eta_minute() const;
  private:
  bool _internal_has_eta_minute() const;
  public:
  void clear_eta_minute();
  uint32_t eta_minute() const;
  void set_eta_minute(uint32_t value);
  private:
  uint32_t _internal_eta_minute() const;
  void _internal_set_eta_minute(uint32_t value);
  public:
 
  // optional float draught = 17 [(.dccl.field) = {
  bool has_draught() const;
  private:
  bool _internal_has_draught() const;
  public:
  void clear_draught();
  float draught() const;
  void set_draught(float value);
  private:
  float _internal_draught() const;
  void _internal_set_draught(float value);
  public:
 
  enum DCCLParameters { DCCL_ID = 519,  DCCL_MAX_BYTES = 1500 };
  typedef boost::units::length_dimension to_bow_dimension;
  
  typedef boost::units::unit<to_bow_dimension,boost::units::si::system> to_bow_unit;
  
  template<typename Quantity >
    void set_to_bow_with_units(Quantity value_w_units)
    { set_to_bow(boost::units::quantity<to_bow_unit,google::protobuf::uint32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity to_bow_with_units() const
    { return Quantity(to_bow() * to_bow_unit()); };
  
  boost::units::quantity< to_bow_unit,google::protobuf::uint32 > to_bow_with_units() const
    { return to_bow_with_units<boost::units::quantity< to_bow_unit,google::protobuf::uint32 > >(); };
  
  typedef boost::units::length_dimension to_stern_dimension;
  
  typedef boost::units::unit<to_stern_dimension,boost::units::si::system> to_stern_unit;
  
  template<typename Quantity >
    void set_to_stern_with_units(Quantity value_w_units)
    { set_to_stern(boost::units::quantity<to_stern_unit,google::protobuf::uint32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity to_stern_with_units() const
    { return Quantity(to_stern() * to_stern_unit()); };
  
  boost::units::quantity< to_stern_unit,google::protobuf::uint32 > to_stern_with_units() const
    { return to_stern_with_units<boost::units::quantity< to_stern_unit,google::protobuf::uint32 > >(); };
  
  typedef boost::units::length_dimension to_port_dimension;
  
  typedef boost::units::unit<to_port_dimension,boost::units::si::system> to_port_unit;
  
  template<typename Quantity >
    void set_to_port_with_units(Quantity value_w_units)
    { set_to_port(boost::units::quantity<to_port_unit,google::protobuf::uint32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity to_port_with_units() const
    { return Quantity(to_port() * to_port_unit()); };
  
  boost::units::quantity< to_port_unit,google::protobuf::uint32 > to_port_with_units() const
    { return to_port_with_units<boost::units::quantity< to_port_unit,google::protobuf::uint32 > >(); };
  
  typedef boost::units::length_dimension to_starboard_dimension;
  
  typedef boost::units::unit<to_starboard_dimension,boost::units::si::system> to_starboard_unit;
  
  template<typename Quantity >
    void set_to_starboard_with_units(Quantity value_w_units)
    { set_to_starboard(boost::units::quantity<to_starboard_unit,google::protobuf::uint32 >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity to_starboard_with_units() const
    { return Quantity(to_starboard() * to_starboard_unit()); };
  
  boost::units::quantity< to_starboard_unit,google::protobuf::uint32 > to_starboard_with_units() const
    { return to_starboard_with_units<boost::units::quantity< to_starboard_unit,google::protobuf::uint32 > >(); };
  
  typedef boost::units::length_dimension draught_dimension;
  
  typedef boost::units::unit<draught_dimension,boost::units::si::system> draught_unit;
  
  template<typename Quantity >
    void set_draught_with_units(Quantity value_w_units)
    { set_draught(boost::units::quantity<draught_unit,float >(value_w_units).value() ); };
  
  template<typename Quantity >
    Quantity draught_with_units() const
    { return Quantity(draught() * draught_unit()); };
  
  boost::units::quantity< draught_unit,float > draught_with_units() const
    { return draught_with_units<boost::units::quantity< draught_unit,float > >(); };
  
  // @@protoc_insertion_point(class_scope:goby.util.ais.protobuf.Voyage)
 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 callsign_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destination_;
    int32_t message_id_;
    int32_t mmsi_;
    int32_t imo_;
    int type_;
    uint32_t to_bow_;
    uint32_t to_stern_;
    uint32_t to_port_;
    uint32_t to_starboard_;
    int fix_type_;
    uint32_t eta_month_;
    uint32_t eta_day_;
    uint32_t eta_hour_;
    uint32_t eta_minute_;
    float draught_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_goby_2futil_2fprotobuf_2fais_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Position
 
// optional int32 message_id = 2 [default = 0, (.dccl.field) = {
inline bool Position::_internal_has_message_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Position::has_message_id() const {
  return _internal_has_message_id();
}
inline void Position::clear_message_id() {
  _impl_.message_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t Position::_internal_message_id() const {
  return _impl_.message_id_;
}
inline int32_t Position::message_id() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.message_id)
  return _internal_message_id();
}
inline void Position::_internal_set_message_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_id_ = value;
}
inline void Position::set_message_id(int32_t value) {
  _internal_set_message_id(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.message_id)
}
 
// optional int32 mmsi = 3 [(.dccl.field) = {
inline bool Position::_internal_has_mmsi() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Position::has_mmsi() const {
  return _internal_has_mmsi();
}
inline void Position::clear_mmsi() {
  _impl_.mmsi_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Position::_internal_mmsi() const {
  return _impl_.mmsi_;
}
inline int32_t Position::mmsi() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.mmsi)
  return _internal_mmsi();
}
inline void Position::_internal_set_mmsi(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mmsi_ = value;
}
inline void Position::set_mmsi(int32_t value) {
  _internal_set_mmsi(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.mmsi)
}
 
// optional .goby.util.ais.protobuf.Status nav_status = 4 [default = AIS_STATUS__NOT_DEFINED];
inline bool Position::_internal_has_nav_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Position::has_nav_status() const {
  return _internal_has_nav_status();
}
inline void Position::clear_nav_status() {
  _impl_.nav_status_ = 15;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::goby::util::ais::protobuf::Status Position::_internal_nav_status() const {
  return static_cast< ::goby::util::ais::protobuf::Status >(_impl_.nav_status_);
}
inline ::goby::util::ais::protobuf::Status Position::nav_status() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.nav_status)
  return _internal_nav_status();
}
inline void Position::_internal_set_nav_status(::goby::util::ais::protobuf::Status value) {
  assert(::goby::util::ais::protobuf::Status_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.nav_status_ = value;
}
inline void Position::set_nav_status(::goby::util::ais::protobuf::Status value) {
  _internal_set_nav_status(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.nav_status)
}
 
// optional .goby.util.ais.protobuf.Position.TurnInfo turn_info = 5 [default = TURN_INFO__NO_TURN_INFORMATION];
inline bool Position::_internal_has_turn_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Position::has_turn_info() const {
  return _internal_has_turn_info();
}
inline void Position::clear_turn_info() {
  _impl_.turn_info_ = 128;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::goby::util::ais::protobuf::Position_TurnInfo Position::_internal_turn_info() const {
  return static_cast< ::goby::util::ais::protobuf::Position_TurnInfo >(_impl_.turn_info_);
}
inline ::goby::util::ais::protobuf::Position_TurnInfo Position::turn_info() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.turn_info)
  return _internal_turn_info();
}
inline void Position::_internal_set_turn_info(::goby::util::ais::protobuf::Position_TurnInfo value) {
  assert(::goby::util::ais::protobuf::Position_TurnInfo_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.turn_info_ = value;
}
inline void Position::set_turn_info(::goby::util::ais::protobuf::Position_TurnInfo value) {
  _internal_set_turn_info(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.turn_info)
}
 
// optional float turn_rate = 6 [(.dccl.field) = {
inline bool Position::_internal_has_turn_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Position::has_turn_rate() const {
  return _internal_has_turn_rate();
}
inline void Position::clear_turn_rate() {
  _impl_.turn_rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float Position::_internal_turn_rate() const {
  return _impl_.turn_rate_;
}
inline float Position::turn_rate() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.turn_rate)
  return _internal_turn_rate();
}
inline void Position::_internal_set_turn_rate(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.turn_rate_ = value;
}
inline void Position::set_turn_rate(float value) {
  _internal_set_turn_rate(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.turn_rate)
}
 
// optional float speed_over_ground = 7 [(.dccl.field) = {
inline bool Position::_internal_has_speed_over_ground() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Position::has_speed_over_ground() const {
  return _internal_has_speed_over_ground();
}
inline void Position::clear_speed_over_ground() {
  _impl_.speed_over_ground_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float Position::_internal_speed_over_ground() const {
  return _impl_.speed_over_ground_;
}
inline float Position::speed_over_ground() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.speed_over_ground)
  return _internal_speed_over_ground();
}
inline void Position::_internal_set_speed_over_ground(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.speed_over_ground_ = value;
}
inline void Position::set_speed_over_ground(float value) {
  _internal_set_speed_over_ground(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.speed_over_ground)
}
 
// optional .goby.util.ais.protobuf.Position.PositionAccuracy position_accuracy = 8 [default = ACCURACY__LOW__ABOVE_10_METERS];
inline bool Position::_internal_has_position_accuracy() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Position::has_position_accuracy() const {
  return _internal_has_position_accuracy();
}
inline void Position::clear_position_accuracy() {
  _impl_.position_accuracy_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::goby::util::ais::protobuf::Position_PositionAccuracy Position::_internal_position_accuracy() const {
  return static_cast< ::goby::util::ais::protobuf::Position_PositionAccuracy >(_impl_.position_accuracy_);
}
inline ::goby::util::ais::protobuf::Position_PositionAccuracy Position::position_accuracy() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.position_accuracy)
  return _internal_position_accuracy();
}
inline void Position::_internal_set_position_accuracy(::goby::util::ais::protobuf::Position_PositionAccuracy value) {
  assert(::goby::util::ais::protobuf::Position_PositionAccuracy_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.position_accuracy_ = value;
}
inline void Position::set_position_accuracy(::goby::util::ais::protobuf::Position_PositionAccuracy value) {
  _internal_set_position_accuracy(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.position_accuracy)
}
 
// optional double lat = 9 [(.dccl.field) = {
inline bool Position::_internal_has_lat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Position::has_lat() const {
  return _internal_has_lat();
}
inline void Position::clear_lat() {
  _impl_.lat_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double Position::_internal_lat() const {
  return _impl_.lat_;
}
inline double Position::lat() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.lat)
  return _internal_lat();
}
inline void Position::_internal_set_lat(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.lat_ = value;
}
inline void Position::set_lat(double value) {
  _internal_set_lat(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.lat)
}
 
// optional double lon = 10 [(.dccl.field) = {
inline bool Position::_internal_has_lon() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Position::has_lon() const {
  return _internal_has_lon();
}
inline void Position::clear_lon() {
  _impl_.lon_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline double Position::_internal_lon() const {
  return _impl_.lon_;
}
inline double Position::lon() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.lon)
  return _internal_lon();
}
inline void Position::_internal_set_lon(double value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.lon_ = value;
}
inline void Position::set_lon(double value) {
  _internal_set_lon(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.lon)
}
 
// optional float course_over_ground = 11 [(.dccl.field) = {
inline bool Position::_internal_has_course_over_ground() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Position::has_course_over_ground() const {
  return _internal_has_course_over_ground();
}
inline void Position::clear_course_over_ground() {
  _impl_.course_over_ground_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float Position::_internal_course_over_ground() const {
  return _impl_.course_over_ground_;
}
inline float Position::course_over_ground() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.course_over_ground)
  return _internal_course_over_ground();
}
inline void Position::_internal_set_course_over_ground(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.course_over_ground_ = value;
}
inline void Position::set_course_over_ground(float value) {
  _internal_set_course_over_ground(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.course_over_ground)
}
 
// optional float true_heading = 12 [(.dccl.field) = {
inline bool Position::_internal_has_true_heading() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Position::has_true_heading() const {
  return _internal_has_true_heading();
}
inline void Position::clear_true_heading() {
  _impl_.true_heading_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float Position::_internal_true_heading() const {
  return _impl_.true_heading_;
}
inline float Position::true_heading() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.true_heading)
  return _internal_true_heading();
}
inline void Position::_internal_set_true_heading(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.true_heading_ = value;
}
inline void Position::set_true_heading(float value) {
  _internal_set_true_heading(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.true_heading)
}
 
// optional int32 report_second = 13 [(.dccl.field) = {
inline bool Position::_internal_has_report_second() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Position::has_report_second() const {
  return _internal_has_report_second();
}
inline void Position::clear_report_second() {
  _impl_.report_second_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t Position::_internal_report_second() const {
  return _impl_.report_second_;
}
inline int32_t Position::report_second() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.report_second)
  return _internal_report_second();
}
inline void Position::_internal_set_report_second(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.report_second_ = value;
}
inline void Position::set_report_second(int32_t value) {
  _internal_set_report_second(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.report_second)
}
 
// optional bool raim = 14 [(.dccl.field) = {
inline bool Position::_internal_has_raim() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Position::has_raim() const {
  return _internal_has_raim();
}
inline void Position::clear_raim() {
  _impl_.raim_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool Position::_internal_raim() const {
  return _impl_.raim_;
}
inline bool Position::raim() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Position.raim)
  return _internal_raim();
}
inline void Position::_internal_set_raim(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.raim_ = value;
}
inline void Position::set_raim(bool value) {
  _internal_set_raim(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Position.raim)
}
 
// -------------------------------------------------------------------
 
// Voyage
 
// optional int32 message_id = 2 [default = 0, (.dccl.field) = {
inline bool Voyage::_internal_has_message_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Voyage::has_message_id() const {
  return _internal_has_message_id();
}
inline void Voyage::clear_message_id() {
  _impl_.message_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t Voyage::_internal_message_id() const {
  return _impl_.message_id_;
}
inline int32_t Voyage::message_id() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.message_id)
  return _internal_message_id();
}
inline void Voyage::_internal_set_message_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.message_id_ = value;
}
inline void Voyage::set_message_id(int32_t value) {
  _internal_set_message_id(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.message_id)
}
 
// optional int32 mmsi = 3 [(.dccl.field) = {
inline bool Voyage::_internal_has_mmsi() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Voyage::has_mmsi() const {
  return _internal_has_mmsi();
}
inline void Voyage::clear_mmsi() {
  _impl_.mmsi_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t Voyage::_internal_mmsi() const {
  return _impl_.mmsi_;
}
inline int32_t Voyage::mmsi() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.mmsi)
  return _internal_mmsi();
}
inline void Voyage::_internal_set_mmsi(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mmsi_ = value;
}
inline void Voyage::set_mmsi(int32_t value) {
  _internal_set_mmsi(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.mmsi)
}
 
// optional int32 imo = 4 [(.dccl.field) = {
inline bool Voyage::_internal_has_imo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Voyage::has_imo() const {
  return _internal_has_imo();
}
inline void Voyage::clear_imo() {
  _impl_.imo_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t Voyage::_internal_imo() const {
  return _impl_.imo_;
}
inline int32_t Voyage::imo() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.imo)
  return _internal_imo();
}
inline void Voyage::_internal_set_imo(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.imo_ = value;
}
inline void Voyage::set_imo(int32_t value) {
  _internal_set_imo(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.imo)
}
 
// optional string callsign = 5 [(.dccl.field) = {
inline bool Voyage::_internal_has_callsign() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Voyage::has_callsign() const {
  return _internal_has_callsign();
}
inline void Voyage::clear_callsign() {
  _impl_.callsign_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Voyage::callsign() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.callsign)
  return _internal_callsign();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Voyage::set_callsign(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.callsign_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.callsign)
}
inline std::string* Voyage::mutable_callsign() {
  std::string* _s = _internal_mutable_callsign();
  // @@protoc_insertion_point(field_mutable:goby.util.ais.protobuf.Voyage.callsign)
  return _s;
}
inline const std::string& Voyage::_internal_callsign() const {
  return _impl_.callsign_.Get();
}
inline void Voyage::_internal_set_callsign(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.callsign_.Set(value, GetArenaForAllocation());
}
inline std::string* Voyage::_internal_mutable_callsign() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.callsign_.Mutable(GetArenaForAllocation());
}
inline std::string* Voyage::release_callsign() {
  // @@protoc_insertion_point(field_release:goby.util.ais.protobuf.Voyage.callsign)
  if (!_internal_has_callsign()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.callsign_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.callsign_.IsDefault()) {
    _impl_.callsign_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Voyage::set_allocated_callsign(std::string* callsign) {
  if (callsign != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.callsign_.SetAllocated(callsign, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.callsign_.IsDefault()) {
    _impl_.callsign_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.util.ais.protobuf.Voyage.callsign)
}
 
// optional string name = 6 [(.dccl.field) = {
inline bool Voyage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Voyage::has_name() const {
  return _internal_has_name();
}
inline void Voyage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Voyage::name() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Voyage::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.name)
}
inline std::string* Voyage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:goby.util.ais.protobuf.Voyage.name)
  return _s;
}
inline const std::string& Voyage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Voyage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Voyage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Voyage::release_name() {
  // @@protoc_insertion_point(field_release:goby.util.ais.protobuf.Voyage.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Voyage::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.util.ais.protobuf.Voyage.name)
}
 
// optional .goby.util.ais.protobuf.Voyage.ShipType type = 7 [default = TYPE__NOT_AVAILABLE];
inline bool Voyage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Voyage::has_type() const {
  return _internal_has_type();
}
inline void Voyage::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::goby::util::ais::protobuf::Voyage_ShipType Voyage::_internal_type() const {
  return static_cast< ::goby::util::ais::protobuf::Voyage_ShipType >(_impl_.type_);
}
inline ::goby::util::ais::protobuf::Voyage_ShipType Voyage::type() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.type)
  return _internal_type();
}
inline void Voyage::_internal_set_type(::goby::util::ais::protobuf::Voyage_ShipType value) {
  assert(::goby::util::ais::protobuf::Voyage_ShipType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.type_ = value;
}
inline void Voyage::set_type(::goby::util::ais::protobuf::Voyage_ShipType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.type)
}
 
// optional uint32 to_bow = 8 [(.dccl.field) = {
inline bool Voyage::_internal_has_to_bow() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Voyage::has_to_bow() const {
  return _internal_has_to_bow();
}
inline void Voyage::clear_to_bow() {
  _impl_.to_bow_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t Voyage::_internal_to_bow() const {
  return _impl_.to_bow_;
}
inline uint32_t Voyage::to_bow() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.to_bow)
  return _internal_to_bow();
}
inline void Voyage::_internal_set_to_bow(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.to_bow_ = value;
}
inline void Voyage::set_to_bow(uint32_t value) {
  _internal_set_to_bow(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.to_bow)
}
 
// optional uint32 to_stern = 9 [(.dccl.field) = {
inline bool Voyage::_internal_has_to_stern() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Voyage::has_to_stern() const {
  return _internal_has_to_stern();
}
inline void Voyage::clear_to_stern() {
  _impl_.to_stern_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t Voyage::_internal_to_stern() const {
  return _impl_.to_stern_;
}
inline uint32_t Voyage::to_stern() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.to_stern)
  return _internal_to_stern();
}
inline void Voyage::_internal_set_to_stern(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.to_stern_ = value;
}
inline void Voyage::set_to_stern(uint32_t value) {
  _internal_set_to_stern(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.to_stern)
}
 
// optional uint32 to_port = 10 [(.dccl.field) = {
inline bool Voyage::_internal_has_to_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Voyage::has_to_port() const {
  return _internal_has_to_port();
}
inline void Voyage::clear_to_port() {
  _impl_.to_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t Voyage::_internal_to_port() const {
  return _impl_.to_port_;
}
inline uint32_t Voyage::to_port() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.to_port)
  return _internal_to_port();
}
inline void Voyage::_internal_set_to_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.to_port_ = value;
}
inline void Voyage::set_to_port(uint32_t value) {
  _internal_set_to_port(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.to_port)
}
 
// optional uint32 to_starboard = 11 [(.dccl.field) = {
inline bool Voyage::_internal_has_to_starboard() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Voyage::has_to_starboard() const {
  return _internal_has_to_starboard();
}
inline void Voyage::clear_to_starboard() {
  _impl_.to_starboard_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Voyage::_internal_to_starboard() const {
  return _impl_.to_starboard_;
}
inline uint32_t Voyage::to_starboard() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.to_starboard)
  return _internal_to_starboard();
}
inline void Voyage::_internal_set_to_starboard(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.to_starboard_ = value;
}
inline void Voyage::set_to_starboard(uint32_t value) {
  _internal_set_to_starboard(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.to_starboard)
}
 
// optional .goby.util.ais.protobuf.Voyage.FixType fix_type = 12 [default = FIX__UNDEFINED];
inline bool Voyage::_internal_has_fix_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Voyage::has_fix_type() const {
  return _internal_has_fix_type();
}
inline void Voyage::clear_fix_type() {
  _impl_.fix_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::goby::util::ais::protobuf::Voyage_FixType Voyage::_internal_fix_type() const {
  return static_cast< ::goby::util::ais::protobuf::Voyage_FixType >(_impl_.fix_type_);
}
inline ::goby::util::ais::protobuf::Voyage_FixType Voyage::fix_type() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.fix_type)
  return _internal_fix_type();
}
inline void Voyage::_internal_set_fix_type(::goby::util::ais::protobuf::Voyage_FixType value) {
  assert(::goby::util::ais::protobuf::Voyage_FixType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.fix_type_ = value;
}
inline void Voyage::set_fix_type(::goby::util::ais::protobuf::Voyage_FixType value) {
  _internal_set_fix_type(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.fix_type)
}
 
// optional uint32 eta_month = 13 [(.dccl.field) = {
inline bool Voyage::_internal_has_eta_month() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Voyage::has_eta_month() const {
  return _internal_has_eta_month();
}
inline void Voyage::clear_eta_month() {
  _impl_.eta_month_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t Voyage::_internal_eta_month() const {
  return _impl_.eta_month_;
}
inline uint32_t Voyage::eta_month() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.eta_month)
  return _internal_eta_month();
}
inline void Voyage::_internal_set_eta_month(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.eta_month_ = value;
}
inline void Voyage::set_eta_month(uint32_t value) {
  _internal_set_eta_month(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.eta_month)
}
 
// optional uint32 eta_day = 14 [(.dccl.field) = {
inline bool Voyage::_internal_has_eta_day() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Voyage::has_eta_day() const {
  return _internal_has_eta_day();
}
inline void Voyage::clear_eta_day() {
  _impl_.eta_day_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t Voyage::_internal_eta_day() const {
  return _impl_.eta_day_;
}
inline uint32_t Voyage::eta_day() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.eta_day)
  return _internal_eta_day();
}
inline void Voyage::_internal_set_eta_day(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.eta_day_ = value;
}
inline void Voyage::set_eta_day(uint32_t value) {
  _internal_set_eta_day(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.eta_day)
}
 
// optional uint32 eta_hour = 15 [(.dccl.field) = {
inline bool Voyage::_internal_has_eta_hour() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Voyage::has_eta_hour() const {
  return _internal_has_eta_hour();
}
inline void Voyage::clear_eta_hour() {
  _impl_.eta_hour_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t Voyage::_internal_eta_hour() const {
  return _impl_.eta_hour_;
}
inline uint32_t Voyage::eta_hour() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.eta_hour)
  return _internal_eta_hour();
}
inline void Voyage::_internal_set_eta_hour(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.eta_hour_ = value;
}
inline void Voyage::set_eta_hour(uint32_t value) {
  _internal_set_eta_hour(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.eta_hour)
}
 
// optional uint32 eta_minute = 16 [(.dccl.field) = {
inline bool Voyage::_internal_has_eta_minute() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Voyage::has_eta_minute() const {
  return _internal_has_eta_minute();
}
inline void Voyage::clear_eta_minute() {
  _impl_.eta_minute_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t Voyage::_internal_eta_minute() const {
  return _impl_.eta_minute_;
}
inline uint32_t Voyage::eta_minute() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.eta_minute)
  return _internal_eta_minute();
}
inline void Voyage::_internal_set_eta_minute(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.eta_minute_ = value;
}
inline void Voyage::set_eta_minute(uint32_t value) {
  _internal_set_eta_minute(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.eta_minute)
}
 
// optional float draught = 17 [(.dccl.field) = {
inline bool Voyage::_internal_has_draught() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Voyage::has_draught() const {
  return _internal_has_draught();
}
inline void Voyage::clear_draught() {
  _impl_.draught_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float Voyage::_internal_draught() const {
  return _impl_.draught_;
}
inline float Voyage::draught() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.draught)
  return _internal_draught();
}
inline void Voyage::_internal_set_draught(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.draught_ = value;
}
inline void Voyage::set_draught(float value) {
  _internal_set_draught(value);
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.draught)
}
 
// optional string destination = 18 [(.dccl.field) = {
inline bool Voyage::_internal_has_destination() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Voyage::has_destination() const {
  return _internal_has_destination();
}
inline void Voyage::clear_destination() {
  _impl_.destination_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Voyage::destination() const {
  // @@protoc_insertion_point(field_get:goby.util.ais.protobuf.Voyage.destination)
  return _internal_destination();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Voyage::set_destination(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.destination_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:goby.util.ais.protobuf.Voyage.destination)
}
inline std::string* Voyage::mutable_destination() {
  std::string* _s = _internal_mutable_destination();
  // @@protoc_insertion_point(field_mutable:goby.util.ais.protobuf.Voyage.destination)
  return _s;
}
inline const std::string& Voyage::_internal_destination() const {
  return _impl_.destination_.Get();
}
inline void Voyage::_internal_set_destination(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.destination_.Set(value, GetArenaForAllocation());
}
inline std::string* Voyage::_internal_mutable_destination() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.destination_.Mutable(GetArenaForAllocation());
}
inline std::string* Voyage::release_destination() {
  // @@protoc_insertion_point(field_release:goby.util.ais.protobuf.Voyage.destination)
  if (!_internal_has_destination()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.destination_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.destination_.IsDefault()) {
    _impl_.destination_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Voyage::set_allocated_destination(std::string* destination) {
  if (destination != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.destination_.SetAllocated(destination, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.destination_.IsDefault()) {
    _impl_.destination_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:goby.util.ais.protobuf.Voyage.destination)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------
 
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protobuf
}  // namespace ais
}  // namespace util
}  // namespace goby
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::goby::util::ais::protobuf::Position_TurnInfo> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::util::ais::protobuf::Position_TurnInfo>() {
  return ::goby::util::ais::protobuf::Position_TurnInfo_descriptor();
}
template <> struct is_proto_enum< ::goby::util::ais::protobuf::Position_PositionAccuracy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::util::ais::protobuf::Position_PositionAccuracy>() {
  return ::goby::util::ais::protobuf::Position_PositionAccuracy_descriptor();
}
template <> struct is_proto_enum< ::goby::util::ais::protobuf::Voyage_ShipType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::util::ais::protobuf::Voyage_ShipType>() {
  return ::goby::util::ais::protobuf::Voyage_ShipType_descriptor();
}
template <> struct is_proto_enum< ::goby::util::ais::protobuf::Voyage_FixType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::util::ais::protobuf::Voyage_FixType>() {
  return ::goby::util::ais::protobuf::Voyage_FixType_descriptor();
}
template <> struct is_proto_enum< ::goby::util::ais::protobuf::Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::goby::util::ais::protobuf::Status>() {
  return ::goby::util::ais::protobuf::Status_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_goby_2futil_2fprotobuf_2fais_2eproto