// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: osi_common.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_osi_5fcommon_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_osi_5fcommon_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#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 3015002 < 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_table_driven.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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_osi_5fcommon_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_osi_5fcommon_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_osi_5fcommon_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_osi_5fcommon_2eproto_metadata_getter(int index);
namespace osi3 {
class BaseMoving;
struct BaseMovingDefaultTypeInternal;
extern BaseMovingDefaultTypeInternal _BaseMoving_default_instance_;
class BaseStationary;
struct BaseStationaryDefaultTypeInternal;
extern BaseStationaryDefaultTypeInternal _BaseStationary_default_instance_;
class Dimension3d;
struct Dimension3dDefaultTypeInternal;
extern Dimension3dDefaultTypeInternal _Dimension3d_default_instance_;
class Identifier;
struct IdentifierDefaultTypeInternal;
extern IdentifierDefaultTypeInternal _Identifier_default_instance_;
class MountingPosition;
struct MountingPositionDefaultTypeInternal;
extern MountingPositionDefaultTypeInternal _MountingPosition_default_instance_;
class Orientation3d;
struct Orientation3dDefaultTypeInternal;
extern Orientation3dDefaultTypeInternal _Orientation3d_default_instance_;
class Spherical3d;
struct Spherical3dDefaultTypeInternal;
extern Spherical3dDefaultTypeInternal _Spherical3d_default_instance_;
class StatePoint;
struct StatePointDefaultTypeInternal;
extern StatePointDefaultTypeInternal _StatePoint_default_instance_;
class Timestamp;
struct TimestampDefaultTypeInternal;
extern TimestampDefaultTypeInternal _Timestamp_default_instance_;
class Vector2d;
struct Vector2dDefaultTypeInternal;
extern Vector2dDefaultTypeInternal _Vector2d_default_instance_;
class Vector3d;
struct Vector3dDefaultTypeInternal;
extern Vector3dDefaultTypeInternal _Vector3d_default_instance_;
class WavelengthData;
struct WavelengthDataDefaultTypeInternal;
extern WavelengthDataDefaultTypeInternal _WavelengthData_default_instance_;
}  // namespace osi3
PROTOBUF_NAMESPACE_OPEN
template<> ::osi3::BaseMoving* Arena::CreateMaybeMessage<::osi3::BaseMoving>(Arena*);
template<> ::osi3::BaseStationary* Arena::CreateMaybeMessage<::osi3::BaseStationary>(Arena*);
template<> ::osi3::Dimension3d* Arena::CreateMaybeMessage<::osi3::Dimension3d>(Arena*);
template<> ::osi3::Identifier* Arena::CreateMaybeMessage<::osi3::Identifier>(Arena*);
template<> ::osi3::MountingPosition* Arena::CreateMaybeMessage<::osi3::MountingPosition>(Arena*);
template<> ::osi3::Orientation3d* Arena::CreateMaybeMessage<::osi3::Orientation3d>(Arena*);
template<> ::osi3::Spherical3d* Arena::CreateMaybeMessage<::osi3::Spherical3d>(Arena*);
template<> ::osi3::StatePoint* Arena::CreateMaybeMessage<::osi3::StatePoint>(Arena*);
template<> ::osi3::Timestamp* Arena::CreateMaybeMessage<::osi3::Timestamp>(Arena*);
template<> ::osi3::Vector2d* Arena::CreateMaybeMessage<::osi3::Vector2d>(Arena*);
template<> ::osi3::Vector3d* Arena::CreateMaybeMessage<::osi3::Vector3d>(Arena*);
template<> ::osi3::WavelengthData* Arena::CreateMaybeMessage<::osi3::WavelengthData>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace osi3 {

// ===================================================================

class Vector3d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Vector3d) */ {
 public:
  inline Vector3d() : Vector3d(nullptr) {}
  virtual ~Vector3d();
  explicit constexpr Vector3d(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Vector3d(const Vector3d& from);
  Vector3d(Vector3d&& from) noexcept
    : Vector3d() {
    *this = ::std::move(from);
  }

  inline Vector3d& operator=(const Vector3d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Vector3d& operator=(Vector3d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Vector3d& default_instance() {
    return *internal_default_instance();
  }
  static inline const Vector3d* internal_default_instance() {
    return reinterpret_cast<const Vector3d*>(
               &_Vector3d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Vector3d& a, Vector3d& b) {
    a.Swap(&b);
  }
  inline void Swap(Vector3d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Vector3d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Vector3d* New() const final {
    return CreateMaybeMessage<Vector3d>(nullptr);
  }

  Vector3d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Vector3d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Vector3d& from);
  void MergeFrom(const Vector3d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Vector3d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Vector3d";
  }
  protected:
  explicit Vector3d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kZFieldNumber = 3,
  };
  // double x = 1;
  void clear_x();
  double x() const;
  void set_x(double value);
  private:
  double _internal_x() const;
  void _internal_set_x(double value);
  public:

  // double y = 2;
  void clear_y();
  double y() const;
  void set_y(double value);
  private:
  double _internal_y() const;
  void _internal_set_y(double value);
  public:

  // double z = 3;
  void clear_z();
  double z() const;
  void set_z(double value);
  private:
  double _internal_z() const;
  void _internal_set_z(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Vector3d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double x_;
  double y_;
  double z_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Vector2d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Vector2d) */ {
 public:
  inline Vector2d() : Vector2d(nullptr) {}
  virtual ~Vector2d();
  explicit constexpr Vector2d(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Vector2d(const Vector2d& from);
  Vector2d(Vector2d&& from) noexcept
    : Vector2d() {
    *this = ::std::move(from);
  }

  inline Vector2d& operator=(const Vector2d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Vector2d& operator=(Vector2d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Vector2d& default_instance() {
    return *internal_default_instance();
  }
  static inline const Vector2d* internal_default_instance() {
    return reinterpret_cast<const Vector2d*>(
               &_Vector2d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Vector2d& a, Vector2d& b) {
    a.Swap(&b);
  }
  inline void Swap(Vector2d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Vector2d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Vector2d* New() const final {
    return CreateMaybeMessage<Vector2d>(nullptr);
  }

  Vector2d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Vector2d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Vector2d& from);
  void MergeFrom(const Vector2d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Vector2d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Vector2d";
  }
  protected:
  explicit Vector2d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
  };
  // double x = 1;
  void clear_x();
  double x() const;
  void set_x(double value);
  private:
  double _internal_x() const;
  void _internal_set_x(double value);
  public:

  // double y = 2;
  void clear_y();
  double y() const;
  void set_y(double value);
  private:
  double _internal_y() const;
  void _internal_set_y(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Vector2d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double x_;
  double y_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Timestamp PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Timestamp) */ {
 public:
  inline Timestamp() : Timestamp(nullptr) {}
  virtual ~Timestamp();
  explicit constexpr Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Timestamp(const Timestamp& from);
  Timestamp(Timestamp&& from) noexcept
    : Timestamp() {
    *this = ::std::move(from);
  }

  inline Timestamp& operator=(const Timestamp& from) {
    CopyFrom(from);
    return *this;
  }
  inline Timestamp& operator=(Timestamp&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Timestamp& default_instance() {
    return *internal_default_instance();
  }
  static inline const Timestamp* internal_default_instance() {
    return reinterpret_cast<const Timestamp*>(
               &_Timestamp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Timestamp& a, Timestamp& b) {
    a.Swap(&b);
  }
  inline void Swap(Timestamp* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Timestamp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Timestamp* New() const final {
    return CreateMaybeMessage<Timestamp>(nullptr);
  }

  Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Timestamp>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Timestamp& from);
  void MergeFrom(const Timestamp& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Timestamp* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Timestamp";
  }
  protected:
  explicit Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSecondsFieldNumber = 1,
    kNanosFieldNumber = 2,
  };
  // int64 seconds = 1;
  void clear_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 seconds() const;
  void set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds() const;
  void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // uint32 nanos = 2;
  void clear_nanos();
  ::PROTOBUF_NAMESPACE_ID::uint32 nanos() const;
  void set_nanos(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_nanos() const;
  void _internal_set_nanos(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Timestamp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_;
  ::PROTOBUF_NAMESPACE_ID::uint32 nanos_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Dimension3d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Dimension3d) */ {
 public:
  inline Dimension3d() : Dimension3d(nullptr) {}
  virtual ~Dimension3d();
  explicit constexpr Dimension3d(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Dimension3d(const Dimension3d& from);
  Dimension3d(Dimension3d&& from) noexcept
    : Dimension3d() {
    *this = ::std::move(from);
  }

  inline Dimension3d& operator=(const Dimension3d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Dimension3d& operator=(Dimension3d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Dimension3d& default_instance() {
    return *internal_default_instance();
  }
  static inline const Dimension3d* internal_default_instance() {
    return reinterpret_cast<const Dimension3d*>(
               &_Dimension3d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Dimension3d& a, Dimension3d& b) {
    a.Swap(&b);
  }
  inline void Swap(Dimension3d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dimension3d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Dimension3d* New() const final {
    return CreateMaybeMessage<Dimension3d>(nullptr);
  }

  Dimension3d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Dimension3d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Dimension3d& from);
  void MergeFrom(const Dimension3d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Dimension3d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Dimension3d";
  }
  protected:
  explicit Dimension3d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLengthFieldNumber = 1,
    kWidthFieldNumber = 2,
    kHeightFieldNumber = 3,
  };
  // double length = 1;
  void clear_length();
  double length() const;
  void set_length(double value);
  private:
  double _internal_length() const;
  void _internal_set_length(double value);
  public:

  // double width = 2;
  void clear_width();
  double width() const;
  void set_width(double value);
  private:
  double _internal_width() const;
  void _internal_set_width(double value);
  public:

  // double height = 3;
  void clear_height();
  double height() const;
  void set_height(double value);
  private:
  double _internal_height() const;
  void _internal_set_height(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Dimension3d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double length_;
  double width_;
  double height_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Orientation3d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Orientation3d) */ {
 public:
  inline Orientation3d() : Orientation3d(nullptr) {}
  virtual ~Orientation3d();
  explicit constexpr Orientation3d(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Orientation3d(const Orientation3d& from);
  Orientation3d(Orientation3d&& from) noexcept
    : Orientation3d() {
    *this = ::std::move(from);
  }

  inline Orientation3d& operator=(const Orientation3d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Orientation3d& operator=(Orientation3d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Orientation3d& default_instance() {
    return *internal_default_instance();
  }
  static inline const Orientation3d* internal_default_instance() {
    return reinterpret_cast<const Orientation3d*>(
               &_Orientation3d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Orientation3d& a, Orientation3d& b) {
    a.Swap(&b);
  }
  inline void Swap(Orientation3d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Orientation3d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Orientation3d* New() const final {
    return CreateMaybeMessage<Orientation3d>(nullptr);
  }

  Orientation3d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Orientation3d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Orientation3d& from);
  void MergeFrom(const Orientation3d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Orientation3d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Orientation3d";
  }
  protected:
  explicit Orientation3d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRollFieldNumber = 1,
    kPitchFieldNumber = 2,
    kYawFieldNumber = 3,
  };
  // double roll = 1;
  void clear_roll();
  double roll() const;
  void set_roll(double value);
  private:
  double _internal_roll() const;
  void _internal_set_roll(double value);
  public:

  // double pitch = 2;
  void clear_pitch();
  double pitch() const;
  void set_pitch(double value);
  private:
  double _internal_pitch() const;
  void _internal_set_pitch(double value);
  public:

  // double yaw = 3;
  void clear_yaw();
  double yaw() const;
  void set_yaw(double value);
  private:
  double _internal_yaw() const;
  void _internal_set_yaw(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Orientation3d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double roll_;
  double pitch_;
  double yaw_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Identifier PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Identifier) */ {
 public:
  inline Identifier() : Identifier(nullptr) {}
  virtual ~Identifier();
  explicit constexpr Identifier(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Identifier(const Identifier& from);
  Identifier(Identifier&& from) noexcept
    : Identifier() {
    *this = ::std::move(from);
  }

  inline Identifier& operator=(const Identifier& from) {
    CopyFrom(from);
    return *this;
  }
  inline Identifier& operator=(Identifier&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Identifier& default_instance() {
    return *internal_default_instance();
  }
  static inline const Identifier* internal_default_instance() {
    return reinterpret_cast<const Identifier*>(
               &_Identifier_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Identifier& a, Identifier& b) {
    a.Swap(&b);
  }
  inline void Swap(Identifier* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Identifier* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Identifier* New() const final {
    return CreateMaybeMessage<Identifier>(nullptr);
  }

  Identifier* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Identifier>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Identifier& from);
  void MergeFrom(const Identifier& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Identifier* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Identifier";
  }
  protected:
  explicit Identifier(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValueFieldNumber = 1,
  };
  // uint64 value = 1;
  void clear_value();
  ::PROTOBUF_NAMESPACE_ID::uint64 value() const;
  void set_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_value() const;
  void _internal_set_value(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Identifier)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint64 value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class MountingPosition PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.MountingPosition) */ {
 public:
  inline MountingPosition() : MountingPosition(nullptr) {}
  virtual ~MountingPosition();
  explicit constexpr MountingPosition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MountingPosition(const MountingPosition& from);
  MountingPosition(MountingPosition&& from) noexcept
    : MountingPosition() {
    *this = ::std::move(from);
  }

  inline MountingPosition& operator=(const MountingPosition& from) {
    CopyFrom(from);
    return *this;
  }
  inline MountingPosition& operator=(MountingPosition&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MountingPosition& default_instance() {
    return *internal_default_instance();
  }
  static inline const MountingPosition* internal_default_instance() {
    return reinterpret_cast<const MountingPosition*>(
               &_MountingPosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(MountingPosition& a, MountingPosition& b) {
    a.Swap(&b);
  }
  inline void Swap(MountingPosition* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MountingPosition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MountingPosition* New() const final {
    return CreateMaybeMessage<MountingPosition>(nullptr);
  }

  MountingPosition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MountingPosition>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MountingPosition& from);
  void MergeFrom(const MountingPosition& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MountingPosition* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.MountingPosition";
  }
  protected:
  explicit MountingPosition(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPositionFieldNumber = 1,
    kOrientationFieldNumber = 2,
  };
  // .osi3.Vector3d position = 1;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::osi3::Vector3d& position() const;
  ::osi3::Vector3d* release_position();
  ::osi3::Vector3d* mutable_position();
  void set_allocated_position(::osi3::Vector3d* position);
  private:
  const ::osi3::Vector3d& _internal_position() const;
  ::osi3::Vector3d* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::osi3::Vector3d* position);
  ::osi3::Vector3d* unsafe_arena_release_position();

  // .osi3.Orientation3d orientation = 2;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::osi3::Orientation3d& orientation() const;
  ::osi3::Orientation3d* release_orientation();
  ::osi3::Orientation3d* mutable_orientation();
  void set_allocated_orientation(::osi3::Orientation3d* orientation);
  private:
  const ::osi3::Orientation3d& _internal_orientation() const;
  ::osi3::Orientation3d* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::osi3::Orientation3d* orientation);
  ::osi3::Orientation3d* unsafe_arena_release_orientation();

  // @@protoc_insertion_point(class_scope:osi3.MountingPosition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Vector3d* position_;
  ::osi3::Orientation3d* orientation_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class Spherical3d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.Spherical3d) */ {
 public:
  inline Spherical3d() : Spherical3d(nullptr) {}
  virtual ~Spherical3d();
  explicit constexpr Spherical3d(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Spherical3d(const Spherical3d& from);
  Spherical3d(Spherical3d&& from) noexcept
    : Spherical3d() {
    *this = ::std::move(from);
  }

  inline Spherical3d& operator=(const Spherical3d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Spherical3d& operator=(Spherical3d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Spherical3d& default_instance() {
    return *internal_default_instance();
  }
  static inline const Spherical3d* internal_default_instance() {
    return reinterpret_cast<const Spherical3d*>(
               &_Spherical3d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(Spherical3d& a, Spherical3d& b) {
    a.Swap(&b);
  }
  inline void Swap(Spherical3d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Spherical3d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Spherical3d* New() const final {
    return CreateMaybeMessage<Spherical3d>(nullptr);
  }

  Spherical3d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Spherical3d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Spherical3d& from);
  void MergeFrom(const Spherical3d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Spherical3d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.Spherical3d";
  }
  protected:
  explicit Spherical3d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDistanceFieldNumber = 1,
    kAzimuthFieldNumber = 2,
    kElevationFieldNumber = 3,
  };
  // double distance = 1;
  void clear_distance();
  double distance() const;
  void set_distance(double value);
  private:
  double _internal_distance() const;
  void _internal_set_distance(double value);
  public:

  // double azimuth = 2;
  void clear_azimuth();
  double azimuth() const;
  void set_azimuth(double value);
  private:
  double _internal_azimuth() const;
  void _internal_set_azimuth(double value);
  public:

  // double elevation = 3;
  void clear_elevation();
  double elevation() const;
  void set_elevation(double value);
  private:
  double _internal_elevation() const;
  void _internal_set_elevation(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Spherical3d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double distance_;
  double azimuth_;
  double elevation_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class BaseStationary PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.BaseStationary) */ {
 public:
  inline BaseStationary() : BaseStationary(nullptr) {}
  virtual ~BaseStationary();
  explicit constexpr BaseStationary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BaseStationary(const BaseStationary& from);
  BaseStationary(BaseStationary&& from) noexcept
    : BaseStationary() {
    *this = ::std::move(from);
  }

  inline BaseStationary& operator=(const BaseStationary& from) {
    CopyFrom(from);
    return *this;
  }
  inline BaseStationary& operator=(BaseStationary&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BaseStationary& default_instance() {
    return *internal_default_instance();
  }
  static inline const BaseStationary* internal_default_instance() {
    return reinterpret_cast<const BaseStationary*>(
               &_BaseStationary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(BaseStationary& a, BaseStationary& b) {
    a.Swap(&b);
  }
  inline void Swap(BaseStationary* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BaseStationary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BaseStationary* New() const final {
    return CreateMaybeMessage<BaseStationary>(nullptr);
  }

  BaseStationary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BaseStationary>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BaseStationary& from);
  void MergeFrom(const BaseStationary& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BaseStationary* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.BaseStationary";
  }
  protected:
  explicit BaseStationary(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBasePolygonFieldNumber = 4,
    kDimensionFieldNumber = 1,
    kPositionFieldNumber = 2,
    kOrientationFieldNumber = 3,
  };
  // repeated .osi3.Vector2d base_polygon = 4;
  int base_polygon_size() const;
  private:
  int _internal_base_polygon_size() const;
  public:
  void clear_base_polygon();
  ::osi3::Vector2d* mutable_base_polygon(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >*
      mutable_base_polygon();
  private:
  const ::osi3::Vector2d& _internal_base_polygon(int index) const;
  ::osi3::Vector2d* _internal_add_base_polygon();
  public:
  const ::osi3::Vector2d& base_polygon(int index) const;
  ::osi3::Vector2d* add_base_polygon();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >&
      base_polygon() const;

  // .osi3.Dimension3d dimension = 1;
  bool has_dimension() const;
  private:
  bool _internal_has_dimension() const;
  public:
  void clear_dimension();
  const ::osi3::Dimension3d& dimension() const;
  ::osi3::Dimension3d* release_dimension();
  ::osi3::Dimension3d* mutable_dimension();
  void set_allocated_dimension(::osi3::Dimension3d* dimension);
  private:
  const ::osi3::Dimension3d& _internal_dimension() const;
  ::osi3::Dimension3d* _internal_mutable_dimension();
  public:
  void unsafe_arena_set_allocated_dimension(
      ::osi3::Dimension3d* dimension);
  ::osi3::Dimension3d* unsafe_arena_release_dimension();

  // .osi3.Vector3d position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::osi3::Vector3d& position() const;
  ::osi3::Vector3d* release_position();
  ::osi3::Vector3d* mutable_position();
  void set_allocated_position(::osi3::Vector3d* position);
  private:
  const ::osi3::Vector3d& _internal_position() const;
  ::osi3::Vector3d* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::osi3::Vector3d* position);
  ::osi3::Vector3d* unsafe_arena_release_position();

  // .osi3.Orientation3d orientation = 3;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::osi3::Orientation3d& orientation() const;
  ::osi3::Orientation3d* release_orientation();
  ::osi3::Orientation3d* mutable_orientation();
  void set_allocated_orientation(::osi3::Orientation3d* orientation);
  private:
  const ::osi3::Orientation3d& _internal_orientation() const;
  ::osi3::Orientation3d* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::osi3::Orientation3d* orientation);
  ::osi3::Orientation3d* unsafe_arena_release_orientation();

  // @@protoc_insertion_point(class_scope:osi3.BaseStationary)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d > base_polygon_;
  ::osi3::Dimension3d* dimension_;
  ::osi3::Vector3d* position_;
  ::osi3::Orientation3d* orientation_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class BaseMoving PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.BaseMoving) */ {
 public:
  inline BaseMoving() : BaseMoving(nullptr) {}
  virtual ~BaseMoving();
  explicit constexpr BaseMoving(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BaseMoving(const BaseMoving& from);
  BaseMoving(BaseMoving&& from) noexcept
    : BaseMoving() {
    *this = ::std::move(from);
  }

  inline BaseMoving& operator=(const BaseMoving& from) {
    CopyFrom(from);
    return *this;
  }
  inline BaseMoving& operator=(BaseMoving&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BaseMoving& default_instance() {
    return *internal_default_instance();
  }
  static inline const BaseMoving* internal_default_instance() {
    return reinterpret_cast<const BaseMoving*>(
               &_BaseMoving_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(BaseMoving& a, BaseMoving& b) {
    a.Swap(&b);
  }
  inline void Swap(BaseMoving* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BaseMoving* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BaseMoving* New() const final {
    return CreateMaybeMessage<BaseMoving>(nullptr);
  }

  BaseMoving* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BaseMoving>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BaseMoving& from);
  void MergeFrom(const BaseMoving& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BaseMoving* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.BaseMoving";
  }
  protected:
  explicit BaseMoving(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBasePolygonFieldNumber = 7,
    kDimensionFieldNumber = 1,
    kPositionFieldNumber = 2,
    kOrientationFieldNumber = 3,
    kVelocityFieldNumber = 4,
    kAccelerationFieldNumber = 5,
    kOrientationRateFieldNumber = 6,
    kOrientationAccelerationFieldNumber = 8,
  };
  // repeated .osi3.Vector2d base_polygon = 7;
  int base_polygon_size() const;
  private:
  int _internal_base_polygon_size() const;
  public:
  void clear_base_polygon();
  ::osi3::Vector2d* mutable_base_polygon(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >*
      mutable_base_polygon();
  private:
  const ::osi3::Vector2d& _internal_base_polygon(int index) const;
  ::osi3::Vector2d* _internal_add_base_polygon();
  public:
  const ::osi3::Vector2d& base_polygon(int index) const;
  ::osi3::Vector2d* add_base_polygon();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >&
      base_polygon() const;

  // .osi3.Dimension3d dimension = 1;
  bool has_dimension() const;
  private:
  bool _internal_has_dimension() const;
  public:
  void clear_dimension();
  const ::osi3::Dimension3d& dimension() const;
  ::osi3::Dimension3d* release_dimension();
  ::osi3::Dimension3d* mutable_dimension();
  void set_allocated_dimension(::osi3::Dimension3d* dimension);
  private:
  const ::osi3::Dimension3d& _internal_dimension() const;
  ::osi3::Dimension3d* _internal_mutable_dimension();
  public:
  void unsafe_arena_set_allocated_dimension(
      ::osi3::Dimension3d* dimension);
  ::osi3::Dimension3d* unsafe_arena_release_dimension();

  // .osi3.Vector3d position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::osi3::Vector3d& position() const;
  ::osi3::Vector3d* release_position();
  ::osi3::Vector3d* mutable_position();
  void set_allocated_position(::osi3::Vector3d* position);
  private:
  const ::osi3::Vector3d& _internal_position() const;
  ::osi3::Vector3d* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::osi3::Vector3d* position);
  ::osi3::Vector3d* unsafe_arena_release_position();

  // .osi3.Orientation3d orientation = 3;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::osi3::Orientation3d& orientation() const;
  ::osi3::Orientation3d* release_orientation();
  ::osi3::Orientation3d* mutable_orientation();
  void set_allocated_orientation(::osi3::Orientation3d* orientation);
  private:
  const ::osi3::Orientation3d& _internal_orientation() const;
  ::osi3::Orientation3d* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::osi3::Orientation3d* orientation);
  ::osi3::Orientation3d* unsafe_arena_release_orientation();

  // .osi3.Vector3d velocity = 4;
  bool has_velocity() const;
  private:
  bool _internal_has_velocity() const;
  public:
  void clear_velocity();
  const ::osi3::Vector3d& velocity() const;
  ::osi3::Vector3d* release_velocity();
  ::osi3::Vector3d* mutable_velocity();
  void set_allocated_velocity(::osi3::Vector3d* velocity);
  private:
  const ::osi3::Vector3d& _internal_velocity() const;
  ::osi3::Vector3d* _internal_mutable_velocity();
  public:
  void unsafe_arena_set_allocated_velocity(
      ::osi3::Vector3d* velocity);
  ::osi3::Vector3d* unsafe_arena_release_velocity();

  // .osi3.Vector3d acceleration = 5;
  bool has_acceleration() const;
  private:
  bool _internal_has_acceleration() const;
  public:
  void clear_acceleration();
  const ::osi3::Vector3d& acceleration() const;
  ::osi3::Vector3d* release_acceleration();
  ::osi3::Vector3d* mutable_acceleration();
  void set_allocated_acceleration(::osi3::Vector3d* acceleration);
  private:
  const ::osi3::Vector3d& _internal_acceleration() const;
  ::osi3::Vector3d* _internal_mutable_acceleration();
  public:
  void unsafe_arena_set_allocated_acceleration(
      ::osi3::Vector3d* acceleration);
  ::osi3::Vector3d* unsafe_arena_release_acceleration();

  // .osi3.Orientation3d orientation_rate = 6;
  bool has_orientation_rate() const;
  private:
  bool _internal_has_orientation_rate() const;
  public:
  void clear_orientation_rate();
  const ::osi3::Orientation3d& orientation_rate() const;
  ::osi3::Orientation3d* release_orientation_rate();
  ::osi3::Orientation3d* mutable_orientation_rate();
  void set_allocated_orientation_rate(::osi3::Orientation3d* orientation_rate);
  private:
  const ::osi3::Orientation3d& _internal_orientation_rate() const;
  ::osi3::Orientation3d* _internal_mutable_orientation_rate();
  public:
  void unsafe_arena_set_allocated_orientation_rate(
      ::osi3::Orientation3d* orientation_rate);
  ::osi3::Orientation3d* unsafe_arena_release_orientation_rate();

  // .osi3.Orientation3d orientation_acceleration = 8;
  bool has_orientation_acceleration() const;
  private:
  bool _internal_has_orientation_acceleration() const;
  public:
  void clear_orientation_acceleration();
  const ::osi3::Orientation3d& orientation_acceleration() const;
  ::osi3::Orientation3d* release_orientation_acceleration();
  ::osi3::Orientation3d* mutable_orientation_acceleration();
  void set_allocated_orientation_acceleration(::osi3::Orientation3d* orientation_acceleration);
  private:
  const ::osi3::Orientation3d& _internal_orientation_acceleration() const;
  ::osi3::Orientation3d* _internal_mutable_orientation_acceleration();
  public:
  void unsafe_arena_set_allocated_orientation_acceleration(
      ::osi3::Orientation3d* orientation_acceleration);
  ::osi3::Orientation3d* unsafe_arena_release_orientation_acceleration();

  // @@protoc_insertion_point(class_scope:osi3.BaseMoving)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d > base_polygon_;
  ::osi3::Dimension3d* dimension_;
  ::osi3::Vector3d* position_;
  ::osi3::Orientation3d* orientation_;
  ::osi3::Vector3d* velocity_;
  ::osi3::Vector3d* acceleration_;
  ::osi3::Orientation3d* orientation_rate_;
  ::osi3::Orientation3d* orientation_acceleration_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class StatePoint PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.StatePoint) */ {
 public:
  inline StatePoint() : StatePoint(nullptr) {}
  virtual ~StatePoint();
  explicit constexpr StatePoint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StatePoint(const StatePoint& from);
  StatePoint(StatePoint&& from) noexcept
    : StatePoint() {
    *this = ::std::move(from);
  }

  inline StatePoint& operator=(const StatePoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline StatePoint& operator=(StatePoint&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StatePoint& default_instance() {
    return *internal_default_instance();
  }
  static inline const StatePoint* internal_default_instance() {
    return reinterpret_cast<const StatePoint*>(
               &_StatePoint_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(StatePoint& a, StatePoint& b) {
    a.Swap(&b);
  }
  inline void Swap(StatePoint* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StatePoint* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline StatePoint* New() const final {
    return CreateMaybeMessage<StatePoint>(nullptr);
  }

  StatePoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StatePoint>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StatePoint& from);
  void MergeFrom(const StatePoint& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StatePoint* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.StatePoint";
  }
  protected:
  explicit StatePoint(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTimestampFieldNumber = 1,
    kPositionFieldNumber = 2,
    kOrientationFieldNumber = 3,
  };
  // .osi3.Timestamp timestamp = 1;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  const ::osi3::Timestamp& timestamp() const;
  ::osi3::Timestamp* release_timestamp();
  ::osi3::Timestamp* mutable_timestamp();
  void set_allocated_timestamp(::osi3::Timestamp* timestamp);
  private:
  const ::osi3::Timestamp& _internal_timestamp() const;
  ::osi3::Timestamp* _internal_mutable_timestamp();
  public:
  void unsafe_arena_set_allocated_timestamp(
      ::osi3::Timestamp* timestamp);
  ::osi3::Timestamp* unsafe_arena_release_timestamp();

  // .osi3.Vector3d position = 2;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::osi3::Vector3d& position() const;
  ::osi3::Vector3d* release_position();
  ::osi3::Vector3d* mutable_position();
  void set_allocated_position(::osi3::Vector3d* position);
  private:
  const ::osi3::Vector3d& _internal_position() const;
  ::osi3::Vector3d* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::osi3::Vector3d* position);
  ::osi3::Vector3d* unsafe_arena_release_position();

  // .osi3.Orientation3d orientation = 3;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::osi3::Orientation3d& orientation() const;
  ::osi3::Orientation3d* release_orientation();
  ::osi3::Orientation3d* mutable_orientation();
  void set_allocated_orientation(::osi3::Orientation3d* orientation);
  private:
  const ::osi3::Orientation3d& _internal_orientation() const;
  ::osi3::Orientation3d* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::osi3::Orientation3d* orientation);
  ::osi3::Orientation3d* unsafe_arena_release_orientation();

  // @@protoc_insertion_point(class_scope:osi3.StatePoint)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Timestamp* timestamp_;
  ::osi3::Vector3d* position_;
  ::osi3::Orientation3d* orientation_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// -------------------------------------------------------------------

class WavelengthData PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:osi3.WavelengthData) */ {
 public:
  inline WavelengthData() : WavelengthData(nullptr) {}
  virtual ~WavelengthData();
  explicit constexpr WavelengthData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  WavelengthData(const WavelengthData& from);
  WavelengthData(WavelengthData&& from) noexcept
    : WavelengthData() {
    *this = ::std::move(from);
  }

  inline WavelengthData& operator=(const WavelengthData& from) {
    CopyFrom(from);
    return *this;
  }
  inline WavelengthData& operator=(WavelengthData&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const WavelengthData& default_instance() {
    return *internal_default_instance();
  }
  static inline const WavelengthData* internal_default_instance() {
    return reinterpret_cast<const WavelengthData*>(
               &_WavelengthData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(WavelengthData& a, WavelengthData& b) {
    a.Swap(&b);
  }
  inline void Swap(WavelengthData* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WavelengthData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline WavelengthData* New() const final {
    return CreateMaybeMessage<WavelengthData>(nullptr);
  }

  WavelengthData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<WavelengthData>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const WavelengthData& from);
  void MergeFrom(const WavelengthData& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WavelengthData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.WavelengthData";
  }
  protected:
  explicit WavelengthData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_osi_5fcommon_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStartFieldNumber = 1,
    kEndFieldNumber = 2,
    kSamplesNumberFieldNumber = 3,
  };
  // double start = 1;
  void clear_start();
  double start() const;
  void set_start(double value);
  private:
  double _internal_start() const;
  void _internal_set_start(double value);
  public:

  // double end = 2;
  void clear_end();
  double end() const;
  void set_end(double value);
  private:
  double _internal_end() const;
  void _internal_set_end(double value);
  public:

  // double samples_number = 3;
  void clear_samples_number();
  double samples_number() const;
  void set_samples_number(double value);
  private:
  double _internal_samples_number() const;
  void _internal_set_samples_number(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.WavelengthData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double start_;
  double end_;
  double samples_number_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fcommon_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Vector3d

// double x = 1;
inline void Vector3d::clear_x() {
  x_ = 0;
}
inline double Vector3d::_internal_x() const {
  return x_;
}
inline double Vector3d::x() const {
  // @@protoc_insertion_point(field_get:osi3.Vector3d.x)
  return _internal_x();
}
inline void Vector3d::_internal_set_x(double value) {
  
  x_ = value;
}
inline void Vector3d::set_x(double value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:osi3.Vector3d.x)
}

// double y = 2;
inline void Vector3d::clear_y() {
  y_ = 0;
}
inline double Vector3d::_internal_y() const {
  return y_;
}
inline double Vector3d::y() const {
  // @@protoc_insertion_point(field_get:osi3.Vector3d.y)
  return _internal_y();
}
inline void Vector3d::_internal_set_y(double value) {
  
  y_ = value;
}
inline void Vector3d::set_y(double value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:osi3.Vector3d.y)
}

// double z = 3;
inline void Vector3d::clear_z() {
  z_ = 0;
}
inline double Vector3d::_internal_z() const {
  return z_;
}
inline double Vector3d::z() const {
  // @@protoc_insertion_point(field_get:osi3.Vector3d.z)
  return _internal_z();
}
inline void Vector3d::_internal_set_z(double value) {
  
  z_ = value;
}
inline void Vector3d::set_z(double value) {
  _internal_set_z(value);
  // @@protoc_insertion_point(field_set:osi3.Vector3d.z)
}

// -------------------------------------------------------------------

// Vector2d

// double x = 1;
inline void Vector2d::clear_x() {
  x_ = 0;
}
inline double Vector2d::_internal_x() const {
  return x_;
}
inline double Vector2d::x() const {
  // @@protoc_insertion_point(field_get:osi3.Vector2d.x)
  return _internal_x();
}
inline void Vector2d::_internal_set_x(double value) {
  
  x_ = value;
}
inline void Vector2d::set_x(double value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:osi3.Vector2d.x)
}

// double y = 2;
inline void Vector2d::clear_y() {
  y_ = 0;
}
inline double Vector2d::_internal_y() const {
  return y_;
}
inline double Vector2d::y() const {
  // @@protoc_insertion_point(field_get:osi3.Vector2d.y)
  return _internal_y();
}
inline void Vector2d::_internal_set_y(double value) {
  
  y_ = value;
}
inline void Vector2d::set_y(double value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:osi3.Vector2d.y)
}

// -------------------------------------------------------------------

// Timestamp

// int64 seconds = 1;
inline void Timestamp::clear_seconds() {
  seconds_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Timestamp::_internal_seconds() const {
  return seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Timestamp::seconds() const {
  // @@protoc_insertion_point(field_get:osi3.Timestamp.seconds)
  return _internal_seconds();
}
inline void Timestamp::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  seconds_ = value;
}
inline void Timestamp::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_seconds(value);
  // @@protoc_insertion_point(field_set:osi3.Timestamp.seconds)
}

// uint32 nanos = 2;
inline void Timestamp::clear_nanos() {
  nanos_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Timestamp::_internal_nanos() const {
  return nanos_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Timestamp::nanos() const {
  // @@protoc_insertion_point(field_get:osi3.Timestamp.nanos)
  return _internal_nanos();
}
inline void Timestamp::_internal_set_nanos(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  nanos_ = value;
}
inline void Timestamp::set_nanos(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_nanos(value);
  // @@protoc_insertion_point(field_set:osi3.Timestamp.nanos)
}

// -------------------------------------------------------------------

// Dimension3d

// double length = 1;
inline void Dimension3d::clear_length() {
  length_ = 0;
}
inline double Dimension3d::_internal_length() const {
  return length_;
}
inline double Dimension3d::length() const {
  // @@protoc_insertion_point(field_get:osi3.Dimension3d.length)
  return _internal_length();
}
inline void Dimension3d::_internal_set_length(double value) {
  
  length_ = value;
}
inline void Dimension3d::set_length(double value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:osi3.Dimension3d.length)
}

// double width = 2;
inline void Dimension3d::clear_width() {
  width_ = 0;
}
inline double Dimension3d::_internal_width() const {
  return width_;
}
inline double Dimension3d::width() const {
  // @@protoc_insertion_point(field_get:osi3.Dimension3d.width)
  return _internal_width();
}
inline void Dimension3d::_internal_set_width(double value) {
  
  width_ = value;
}
inline void Dimension3d::set_width(double value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:osi3.Dimension3d.width)
}

// double height = 3;
inline void Dimension3d::clear_height() {
  height_ = 0;
}
inline double Dimension3d::_internal_height() const {
  return height_;
}
inline double Dimension3d::height() const {
  // @@protoc_insertion_point(field_get:osi3.Dimension3d.height)
  return _internal_height();
}
inline void Dimension3d::_internal_set_height(double value) {
  
  height_ = value;
}
inline void Dimension3d::set_height(double value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:osi3.Dimension3d.height)
}

// -------------------------------------------------------------------

// Orientation3d

// double roll = 1;
inline void Orientation3d::clear_roll() {
  roll_ = 0;
}
inline double Orientation3d::_internal_roll() const {
  return roll_;
}
inline double Orientation3d::roll() const {
  // @@protoc_insertion_point(field_get:osi3.Orientation3d.roll)
  return _internal_roll();
}
inline void Orientation3d::_internal_set_roll(double value) {
  
  roll_ = value;
}
inline void Orientation3d::set_roll(double value) {
  _internal_set_roll(value);
  // @@protoc_insertion_point(field_set:osi3.Orientation3d.roll)
}

// double pitch = 2;
inline void Orientation3d::clear_pitch() {
  pitch_ = 0;
}
inline double Orientation3d::_internal_pitch() const {
  return pitch_;
}
inline double Orientation3d::pitch() const {
  // @@protoc_insertion_point(field_get:osi3.Orientation3d.pitch)
  return _internal_pitch();
}
inline void Orientation3d::_internal_set_pitch(double value) {
  
  pitch_ = value;
}
inline void Orientation3d::set_pitch(double value) {
  _internal_set_pitch(value);
  // @@protoc_insertion_point(field_set:osi3.Orientation3d.pitch)
}

// double yaw = 3;
inline void Orientation3d::clear_yaw() {
  yaw_ = 0;
}
inline double Orientation3d::_internal_yaw() const {
  return yaw_;
}
inline double Orientation3d::yaw() const {
  // @@protoc_insertion_point(field_get:osi3.Orientation3d.yaw)
  return _internal_yaw();
}
inline void Orientation3d::_internal_set_yaw(double value) {
  
  yaw_ = value;
}
inline void Orientation3d::set_yaw(double value) {
  _internal_set_yaw(value);
  // @@protoc_insertion_point(field_set:osi3.Orientation3d.yaw)
}

// -------------------------------------------------------------------

// Identifier

// uint64 value = 1;
inline void Identifier::clear_value() {
  value_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Identifier::_internal_value() const {
  return value_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Identifier::value() const {
  // @@protoc_insertion_point(field_get:osi3.Identifier.value)
  return _internal_value();
}
inline void Identifier::_internal_set_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  value_ = value;
}
inline void Identifier::set_value(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:osi3.Identifier.value)
}

// -------------------------------------------------------------------

// MountingPosition

// .osi3.Vector3d position = 1;
inline bool MountingPosition::_internal_has_position() const {
  return this != internal_default_instance() && position_ != nullptr;
}
inline bool MountingPosition::has_position() const {
  return _internal_has_position();
}
inline void MountingPosition::clear_position() {
  if (GetArena() == nullptr && position_ != nullptr) {
    delete position_;
  }
  position_ = nullptr;
}
inline const ::osi3::Vector3d& MountingPosition::_internal_position() const {
  const ::osi3::Vector3d* p = position_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& MountingPosition::position() const {
  // @@protoc_insertion_point(field_get:osi3.MountingPosition.position)
  return _internal_position();
}
inline void MountingPosition::unsafe_arena_set_allocated_position(
    ::osi3::Vector3d* position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position_);
  }
  position_ = position;
  if (position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.MountingPosition.position)
}
inline ::osi3::Vector3d* MountingPosition::release_position() {
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* MountingPosition::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:osi3.MountingPosition.position)
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* MountingPosition::_internal_mutable_position() {
  
  if (position_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    position_ = p;
  }
  return position_;
}
inline ::osi3::Vector3d* MountingPosition::mutable_position() {
  // @@protoc_insertion_point(field_mutable:osi3.MountingPosition.position)
  return _internal_mutable_position();
}
inline void MountingPosition::set_allocated_position(::osi3::Vector3d* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete position_;
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    
  } else {
    
  }
  position_ = position;
  // @@protoc_insertion_point(field_set_allocated:osi3.MountingPosition.position)
}

// .osi3.Orientation3d orientation = 2;
inline bool MountingPosition::_internal_has_orientation() const {
  return this != internal_default_instance() && orientation_ != nullptr;
}
inline bool MountingPosition::has_orientation() const {
  return _internal_has_orientation();
}
inline void MountingPosition::clear_orientation() {
  if (GetArena() == nullptr && orientation_ != nullptr) {
    delete orientation_;
  }
  orientation_ = nullptr;
}
inline const ::osi3::Orientation3d& MountingPosition::_internal_orientation() const {
  const ::osi3::Orientation3d* p = orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& MountingPosition::orientation() const {
  // @@protoc_insertion_point(field_get:osi3.MountingPosition.orientation)
  return _internal_orientation();
}
inline void MountingPosition::unsafe_arena_set_allocated_orientation(
    ::osi3::Orientation3d* orientation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_);
  }
  orientation_ = orientation;
  if (orientation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.MountingPosition.orientation)
}
inline ::osi3::Orientation3d* MountingPosition::release_orientation() {
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* MountingPosition::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:osi3.MountingPosition.orientation)
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* MountingPosition::_internal_mutable_orientation() {
  
  if (orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_ = p;
  }
  return orientation_;
}
inline ::osi3::Orientation3d* MountingPosition::mutable_orientation() {
  // @@protoc_insertion_point(field_mutable:osi3.MountingPosition.orientation)
  return _internal_mutable_orientation();
}
inline void MountingPosition::set_allocated_orientation(::osi3::Orientation3d* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_;
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation);
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    
  } else {
    
  }
  orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:osi3.MountingPosition.orientation)
}

// -------------------------------------------------------------------

// Spherical3d

// double distance = 1;
inline void Spherical3d::clear_distance() {
  distance_ = 0;
}
inline double Spherical3d::_internal_distance() const {
  return distance_;
}
inline double Spherical3d::distance() const {
  // @@protoc_insertion_point(field_get:osi3.Spherical3d.distance)
  return _internal_distance();
}
inline void Spherical3d::_internal_set_distance(double value) {
  
  distance_ = value;
}
inline void Spherical3d::set_distance(double value) {
  _internal_set_distance(value);
  // @@protoc_insertion_point(field_set:osi3.Spherical3d.distance)
}

// double azimuth = 2;
inline void Spherical3d::clear_azimuth() {
  azimuth_ = 0;
}
inline double Spherical3d::_internal_azimuth() const {
  return azimuth_;
}
inline double Spherical3d::azimuth() const {
  // @@protoc_insertion_point(field_get:osi3.Spherical3d.azimuth)
  return _internal_azimuth();
}
inline void Spherical3d::_internal_set_azimuth(double value) {
  
  azimuth_ = value;
}
inline void Spherical3d::set_azimuth(double value) {
  _internal_set_azimuth(value);
  // @@protoc_insertion_point(field_set:osi3.Spherical3d.azimuth)
}

// double elevation = 3;
inline void Spherical3d::clear_elevation() {
  elevation_ = 0;
}
inline double Spherical3d::_internal_elevation() const {
  return elevation_;
}
inline double Spherical3d::elevation() const {
  // @@protoc_insertion_point(field_get:osi3.Spherical3d.elevation)
  return _internal_elevation();
}
inline void Spherical3d::_internal_set_elevation(double value) {
  
  elevation_ = value;
}
inline void Spherical3d::set_elevation(double value) {
  _internal_set_elevation(value);
  // @@protoc_insertion_point(field_set:osi3.Spherical3d.elevation)
}

// -------------------------------------------------------------------

// BaseStationary

// .osi3.Dimension3d dimension = 1;
inline bool BaseStationary::_internal_has_dimension() const {
  return this != internal_default_instance() && dimension_ != nullptr;
}
inline bool BaseStationary::has_dimension() const {
  return _internal_has_dimension();
}
inline void BaseStationary::clear_dimension() {
  if (GetArena() == nullptr && dimension_ != nullptr) {
    delete dimension_;
  }
  dimension_ = nullptr;
}
inline const ::osi3::Dimension3d& BaseStationary::_internal_dimension() const {
  const ::osi3::Dimension3d* p = dimension_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Dimension3d&>(
      ::osi3::_Dimension3d_default_instance_);
}
inline const ::osi3::Dimension3d& BaseStationary::dimension() const {
  // @@protoc_insertion_point(field_get:osi3.BaseStationary.dimension)
  return _internal_dimension();
}
inline void BaseStationary::unsafe_arena_set_allocated_dimension(
    ::osi3::Dimension3d* dimension) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dimension_);
  }
  dimension_ = dimension;
  if (dimension) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseStationary.dimension)
}
inline ::osi3::Dimension3d* BaseStationary::release_dimension() {
  
  ::osi3::Dimension3d* temp = dimension_;
  dimension_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Dimension3d* BaseStationary::unsafe_arena_release_dimension() {
  // @@protoc_insertion_point(field_release:osi3.BaseStationary.dimension)
  
  ::osi3::Dimension3d* temp = dimension_;
  dimension_ = nullptr;
  return temp;
}
inline ::osi3::Dimension3d* BaseStationary::_internal_mutable_dimension() {
  
  if (dimension_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Dimension3d>(GetArena());
    dimension_ = p;
  }
  return dimension_;
}
inline ::osi3::Dimension3d* BaseStationary::mutable_dimension() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseStationary.dimension)
  return _internal_mutable_dimension();
}
inline void BaseStationary::set_allocated_dimension(::osi3::Dimension3d* dimension) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete dimension_;
  }
  if (dimension) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(dimension);
    if (message_arena != submessage_arena) {
      dimension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dimension, submessage_arena);
    }
    
  } else {
    
  }
  dimension_ = dimension;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseStationary.dimension)
}

// .osi3.Vector3d position = 2;
inline bool BaseStationary::_internal_has_position() const {
  return this != internal_default_instance() && position_ != nullptr;
}
inline bool BaseStationary::has_position() const {
  return _internal_has_position();
}
inline void BaseStationary::clear_position() {
  if (GetArena() == nullptr && position_ != nullptr) {
    delete position_;
  }
  position_ = nullptr;
}
inline const ::osi3::Vector3d& BaseStationary::_internal_position() const {
  const ::osi3::Vector3d* p = position_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& BaseStationary::position() const {
  // @@protoc_insertion_point(field_get:osi3.BaseStationary.position)
  return _internal_position();
}
inline void BaseStationary::unsafe_arena_set_allocated_position(
    ::osi3::Vector3d* position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position_);
  }
  position_ = position;
  if (position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseStationary.position)
}
inline ::osi3::Vector3d* BaseStationary::release_position() {
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* BaseStationary::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:osi3.BaseStationary.position)
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* BaseStationary::_internal_mutable_position() {
  
  if (position_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    position_ = p;
  }
  return position_;
}
inline ::osi3::Vector3d* BaseStationary::mutable_position() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseStationary.position)
  return _internal_mutable_position();
}
inline void BaseStationary::set_allocated_position(::osi3::Vector3d* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete position_;
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    
  } else {
    
  }
  position_ = position;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseStationary.position)
}

// .osi3.Orientation3d orientation = 3;
inline bool BaseStationary::_internal_has_orientation() const {
  return this != internal_default_instance() && orientation_ != nullptr;
}
inline bool BaseStationary::has_orientation() const {
  return _internal_has_orientation();
}
inline void BaseStationary::clear_orientation() {
  if (GetArena() == nullptr && orientation_ != nullptr) {
    delete orientation_;
  }
  orientation_ = nullptr;
}
inline const ::osi3::Orientation3d& BaseStationary::_internal_orientation() const {
  const ::osi3::Orientation3d* p = orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& BaseStationary::orientation() const {
  // @@protoc_insertion_point(field_get:osi3.BaseStationary.orientation)
  return _internal_orientation();
}
inline void BaseStationary::unsafe_arena_set_allocated_orientation(
    ::osi3::Orientation3d* orientation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_);
  }
  orientation_ = orientation;
  if (orientation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseStationary.orientation)
}
inline ::osi3::Orientation3d* BaseStationary::release_orientation() {
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* BaseStationary::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:osi3.BaseStationary.orientation)
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* BaseStationary::_internal_mutable_orientation() {
  
  if (orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_ = p;
  }
  return orientation_;
}
inline ::osi3::Orientation3d* BaseStationary::mutable_orientation() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseStationary.orientation)
  return _internal_mutable_orientation();
}
inline void BaseStationary::set_allocated_orientation(::osi3::Orientation3d* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_;
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation);
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    
  } else {
    
  }
  orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseStationary.orientation)
}

// repeated .osi3.Vector2d base_polygon = 4;
inline int BaseStationary::_internal_base_polygon_size() const {
  return base_polygon_.size();
}
inline int BaseStationary::base_polygon_size() const {
  return _internal_base_polygon_size();
}
inline void BaseStationary::clear_base_polygon() {
  base_polygon_.Clear();
}
inline ::osi3::Vector2d* BaseStationary::mutable_base_polygon(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.BaseStationary.base_polygon)
  return base_polygon_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >*
BaseStationary::mutable_base_polygon() {
  // @@protoc_insertion_point(field_mutable_list:osi3.BaseStationary.base_polygon)
  return &base_polygon_;
}
inline const ::osi3::Vector2d& BaseStationary::_internal_base_polygon(int index) const {
  return base_polygon_.Get(index);
}
inline const ::osi3::Vector2d& BaseStationary::base_polygon(int index) const {
  // @@protoc_insertion_point(field_get:osi3.BaseStationary.base_polygon)
  return _internal_base_polygon(index);
}
inline ::osi3::Vector2d* BaseStationary::_internal_add_base_polygon() {
  return base_polygon_.Add();
}
inline ::osi3::Vector2d* BaseStationary::add_base_polygon() {
  // @@protoc_insertion_point(field_add:osi3.BaseStationary.base_polygon)
  return _internal_add_base_polygon();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >&
BaseStationary::base_polygon() const {
  // @@protoc_insertion_point(field_list:osi3.BaseStationary.base_polygon)
  return base_polygon_;
}

// -------------------------------------------------------------------

// BaseMoving

// .osi3.Dimension3d dimension = 1;
inline bool BaseMoving::_internal_has_dimension() const {
  return this != internal_default_instance() && dimension_ != nullptr;
}
inline bool BaseMoving::has_dimension() const {
  return _internal_has_dimension();
}
inline void BaseMoving::clear_dimension() {
  if (GetArena() == nullptr && dimension_ != nullptr) {
    delete dimension_;
  }
  dimension_ = nullptr;
}
inline const ::osi3::Dimension3d& BaseMoving::_internal_dimension() const {
  const ::osi3::Dimension3d* p = dimension_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Dimension3d&>(
      ::osi3::_Dimension3d_default_instance_);
}
inline const ::osi3::Dimension3d& BaseMoving::dimension() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.dimension)
  return _internal_dimension();
}
inline void BaseMoving::unsafe_arena_set_allocated_dimension(
    ::osi3::Dimension3d* dimension) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dimension_);
  }
  dimension_ = dimension;
  if (dimension) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.dimension)
}
inline ::osi3::Dimension3d* BaseMoving::release_dimension() {
  
  ::osi3::Dimension3d* temp = dimension_;
  dimension_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Dimension3d* BaseMoving::unsafe_arena_release_dimension() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.dimension)
  
  ::osi3::Dimension3d* temp = dimension_;
  dimension_ = nullptr;
  return temp;
}
inline ::osi3::Dimension3d* BaseMoving::_internal_mutable_dimension() {
  
  if (dimension_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Dimension3d>(GetArena());
    dimension_ = p;
  }
  return dimension_;
}
inline ::osi3::Dimension3d* BaseMoving::mutable_dimension() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.dimension)
  return _internal_mutable_dimension();
}
inline void BaseMoving::set_allocated_dimension(::osi3::Dimension3d* dimension) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete dimension_;
  }
  if (dimension) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(dimension);
    if (message_arena != submessage_arena) {
      dimension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dimension, submessage_arena);
    }
    
  } else {
    
  }
  dimension_ = dimension;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.dimension)
}

// .osi3.Vector3d position = 2;
inline bool BaseMoving::_internal_has_position() const {
  return this != internal_default_instance() && position_ != nullptr;
}
inline bool BaseMoving::has_position() const {
  return _internal_has_position();
}
inline void BaseMoving::clear_position() {
  if (GetArena() == nullptr && position_ != nullptr) {
    delete position_;
  }
  position_ = nullptr;
}
inline const ::osi3::Vector3d& BaseMoving::_internal_position() const {
  const ::osi3::Vector3d* p = position_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& BaseMoving::position() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.position)
  return _internal_position();
}
inline void BaseMoving::unsafe_arena_set_allocated_position(
    ::osi3::Vector3d* position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position_);
  }
  position_ = position;
  if (position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.position)
}
inline ::osi3::Vector3d* BaseMoving::release_position() {
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.position)
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::_internal_mutable_position() {
  
  if (position_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    position_ = p;
  }
  return position_;
}
inline ::osi3::Vector3d* BaseMoving::mutable_position() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.position)
  return _internal_mutable_position();
}
inline void BaseMoving::set_allocated_position(::osi3::Vector3d* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete position_;
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    
  } else {
    
  }
  position_ = position;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.position)
}

// .osi3.Orientation3d orientation = 3;
inline bool BaseMoving::_internal_has_orientation() const {
  return this != internal_default_instance() && orientation_ != nullptr;
}
inline bool BaseMoving::has_orientation() const {
  return _internal_has_orientation();
}
inline void BaseMoving::clear_orientation() {
  if (GetArena() == nullptr && orientation_ != nullptr) {
    delete orientation_;
  }
  orientation_ = nullptr;
}
inline const ::osi3::Orientation3d& BaseMoving::_internal_orientation() const {
  const ::osi3::Orientation3d* p = orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& BaseMoving::orientation() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.orientation)
  return _internal_orientation();
}
inline void BaseMoving::unsafe_arena_set_allocated_orientation(
    ::osi3::Orientation3d* orientation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_);
  }
  orientation_ = orientation;
  if (orientation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.orientation)
}
inline ::osi3::Orientation3d* BaseMoving::release_orientation() {
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.orientation)
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::_internal_mutable_orientation() {
  
  if (orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_ = p;
  }
  return orientation_;
}
inline ::osi3::Orientation3d* BaseMoving::mutable_orientation() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.orientation)
  return _internal_mutable_orientation();
}
inline void BaseMoving::set_allocated_orientation(::osi3::Orientation3d* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_;
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation);
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    
  } else {
    
  }
  orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.orientation)
}

// .osi3.Vector3d velocity = 4;
inline bool BaseMoving::_internal_has_velocity() const {
  return this != internal_default_instance() && velocity_ != nullptr;
}
inline bool BaseMoving::has_velocity() const {
  return _internal_has_velocity();
}
inline void BaseMoving::clear_velocity() {
  if (GetArena() == nullptr && velocity_ != nullptr) {
    delete velocity_;
  }
  velocity_ = nullptr;
}
inline const ::osi3::Vector3d& BaseMoving::_internal_velocity() const {
  const ::osi3::Vector3d* p = velocity_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& BaseMoving::velocity() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.velocity)
  return _internal_velocity();
}
inline void BaseMoving::unsafe_arena_set_allocated_velocity(
    ::osi3::Vector3d* velocity) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(velocity_);
  }
  velocity_ = velocity;
  if (velocity) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.velocity)
}
inline ::osi3::Vector3d* BaseMoving::release_velocity() {
  
  ::osi3::Vector3d* temp = velocity_;
  velocity_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::unsafe_arena_release_velocity() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.velocity)
  
  ::osi3::Vector3d* temp = velocity_;
  velocity_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::_internal_mutable_velocity() {
  
  if (velocity_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    velocity_ = p;
  }
  return velocity_;
}
inline ::osi3::Vector3d* BaseMoving::mutable_velocity() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.velocity)
  return _internal_mutable_velocity();
}
inline void BaseMoving::set_allocated_velocity(::osi3::Vector3d* velocity) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete velocity_;
  }
  if (velocity) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(velocity);
    if (message_arena != submessage_arena) {
      velocity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, velocity, submessage_arena);
    }
    
  } else {
    
  }
  velocity_ = velocity;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.velocity)
}

// .osi3.Vector3d acceleration = 5;
inline bool BaseMoving::_internal_has_acceleration() const {
  return this != internal_default_instance() && acceleration_ != nullptr;
}
inline bool BaseMoving::has_acceleration() const {
  return _internal_has_acceleration();
}
inline void BaseMoving::clear_acceleration() {
  if (GetArena() == nullptr && acceleration_ != nullptr) {
    delete acceleration_;
  }
  acceleration_ = nullptr;
}
inline const ::osi3::Vector3d& BaseMoving::_internal_acceleration() const {
  const ::osi3::Vector3d* p = acceleration_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& BaseMoving::acceleration() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.acceleration)
  return _internal_acceleration();
}
inline void BaseMoving::unsafe_arena_set_allocated_acceleration(
    ::osi3::Vector3d* acceleration) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(acceleration_);
  }
  acceleration_ = acceleration;
  if (acceleration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.acceleration)
}
inline ::osi3::Vector3d* BaseMoving::release_acceleration() {
  
  ::osi3::Vector3d* temp = acceleration_;
  acceleration_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::unsafe_arena_release_acceleration() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.acceleration)
  
  ::osi3::Vector3d* temp = acceleration_;
  acceleration_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* BaseMoving::_internal_mutable_acceleration() {
  
  if (acceleration_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    acceleration_ = p;
  }
  return acceleration_;
}
inline ::osi3::Vector3d* BaseMoving::mutable_acceleration() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.acceleration)
  return _internal_mutable_acceleration();
}
inline void BaseMoving::set_allocated_acceleration(::osi3::Vector3d* acceleration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete acceleration_;
  }
  if (acceleration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(acceleration);
    if (message_arena != submessage_arena) {
      acceleration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, acceleration, submessage_arena);
    }
    
  } else {
    
  }
  acceleration_ = acceleration;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.acceleration)
}

// .osi3.Orientation3d orientation_rate = 6;
inline bool BaseMoving::_internal_has_orientation_rate() const {
  return this != internal_default_instance() && orientation_rate_ != nullptr;
}
inline bool BaseMoving::has_orientation_rate() const {
  return _internal_has_orientation_rate();
}
inline void BaseMoving::clear_orientation_rate() {
  if (GetArena() == nullptr && orientation_rate_ != nullptr) {
    delete orientation_rate_;
  }
  orientation_rate_ = nullptr;
}
inline const ::osi3::Orientation3d& BaseMoving::_internal_orientation_rate() const {
  const ::osi3::Orientation3d* p = orientation_rate_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& BaseMoving::orientation_rate() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.orientation_rate)
  return _internal_orientation_rate();
}
inline void BaseMoving::unsafe_arena_set_allocated_orientation_rate(
    ::osi3::Orientation3d* orientation_rate) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_rate_);
  }
  orientation_rate_ = orientation_rate;
  if (orientation_rate) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.orientation_rate)
}
inline ::osi3::Orientation3d* BaseMoving::release_orientation_rate() {
  
  ::osi3::Orientation3d* temp = orientation_rate_;
  orientation_rate_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::unsafe_arena_release_orientation_rate() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.orientation_rate)
  
  ::osi3::Orientation3d* temp = orientation_rate_;
  orientation_rate_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::_internal_mutable_orientation_rate() {
  
  if (orientation_rate_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_rate_ = p;
  }
  return orientation_rate_;
}
inline ::osi3::Orientation3d* BaseMoving::mutable_orientation_rate() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.orientation_rate)
  return _internal_mutable_orientation_rate();
}
inline void BaseMoving::set_allocated_orientation_rate(::osi3::Orientation3d* orientation_rate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_rate_;
  }
  if (orientation_rate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation_rate);
    if (message_arena != submessage_arena) {
      orientation_rate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation_rate, submessage_arena);
    }
    
  } else {
    
  }
  orientation_rate_ = orientation_rate;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.orientation_rate)
}

// .osi3.Orientation3d orientation_acceleration = 8;
inline bool BaseMoving::_internal_has_orientation_acceleration() const {
  return this != internal_default_instance() && orientation_acceleration_ != nullptr;
}
inline bool BaseMoving::has_orientation_acceleration() const {
  return _internal_has_orientation_acceleration();
}
inline void BaseMoving::clear_orientation_acceleration() {
  if (GetArena() == nullptr && orientation_acceleration_ != nullptr) {
    delete orientation_acceleration_;
  }
  orientation_acceleration_ = nullptr;
}
inline const ::osi3::Orientation3d& BaseMoving::_internal_orientation_acceleration() const {
  const ::osi3::Orientation3d* p = orientation_acceleration_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& BaseMoving::orientation_acceleration() const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.orientation_acceleration)
  return _internal_orientation_acceleration();
}
inline void BaseMoving::unsafe_arena_set_allocated_orientation_acceleration(
    ::osi3::Orientation3d* orientation_acceleration) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_acceleration_);
  }
  orientation_acceleration_ = orientation_acceleration;
  if (orientation_acceleration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.BaseMoving.orientation_acceleration)
}
inline ::osi3::Orientation3d* BaseMoving::release_orientation_acceleration() {
  
  ::osi3::Orientation3d* temp = orientation_acceleration_;
  orientation_acceleration_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::unsafe_arena_release_orientation_acceleration() {
  // @@protoc_insertion_point(field_release:osi3.BaseMoving.orientation_acceleration)
  
  ::osi3::Orientation3d* temp = orientation_acceleration_;
  orientation_acceleration_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* BaseMoving::_internal_mutable_orientation_acceleration() {
  
  if (orientation_acceleration_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_acceleration_ = p;
  }
  return orientation_acceleration_;
}
inline ::osi3::Orientation3d* BaseMoving::mutable_orientation_acceleration() {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.orientation_acceleration)
  return _internal_mutable_orientation_acceleration();
}
inline void BaseMoving::set_allocated_orientation_acceleration(::osi3::Orientation3d* orientation_acceleration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_acceleration_;
  }
  if (orientation_acceleration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation_acceleration);
    if (message_arena != submessage_arena) {
      orientation_acceleration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation_acceleration, submessage_arena);
    }
    
  } else {
    
  }
  orientation_acceleration_ = orientation_acceleration;
  // @@protoc_insertion_point(field_set_allocated:osi3.BaseMoving.orientation_acceleration)
}

// repeated .osi3.Vector2d base_polygon = 7;
inline int BaseMoving::_internal_base_polygon_size() const {
  return base_polygon_.size();
}
inline int BaseMoving::base_polygon_size() const {
  return _internal_base_polygon_size();
}
inline void BaseMoving::clear_base_polygon() {
  base_polygon_.Clear();
}
inline ::osi3::Vector2d* BaseMoving::mutable_base_polygon(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.BaseMoving.base_polygon)
  return base_polygon_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >*
BaseMoving::mutable_base_polygon() {
  // @@protoc_insertion_point(field_mutable_list:osi3.BaseMoving.base_polygon)
  return &base_polygon_;
}
inline const ::osi3::Vector2d& BaseMoving::_internal_base_polygon(int index) const {
  return base_polygon_.Get(index);
}
inline const ::osi3::Vector2d& BaseMoving::base_polygon(int index) const {
  // @@protoc_insertion_point(field_get:osi3.BaseMoving.base_polygon)
  return _internal_base_polygon(index);
}
inline ::osi3::Vector2d* BaseMoving::_internal_add_base_polygon() {
  return base_polygon_.Add();
}
inline ::osi3::Vector2d* BaseMoving::add_base_polygon() {
  // @@protoc_insertion_point(field_add:osi3.BaseMoving.base_polygon)
  return _internal_add_base_polygon();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector2d >&
BaseMoving::base_polygon() const {
  // @@protoc_insertion_point(field_list:osi3.BaseMoving.base_polygon)
  return base_polygon_;
}

// -------------------------------------------------------------------

// StatePoint

// .osi3.Timestamp timestamp = 1;
inline bool StatePoint::_internal_has_timestamp() const {
  return this != internal_default_instance() && timestamp_ != nullptr;
}
inline bool StatePoint::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void StatePoint::clear_timestamp() {
  if (GetArena() == nullptr && timestamp_ != nullptr) {
    delete timestamp_;
  }
  timestamp_ = nullptr;
}
inline const ::osi3::Timestamp& StatePoint::_internal_timestamp() const {
  const ::osi3::Timestamp* p = timestamp_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Timestamp&>(
      ::osi3::_Timestamp_default_instance_);
}
inline const ::osi3::Timestamp& StatePoint::timestamp() const {
  // @@protoc_insertion_point(field_get:osi3.StatePoint.timestamp)
  return _internal_timestamp();
}
inline void StatePoint::unsafe_arena_set_allocated_timestamp(
    ::osi3::Timestamp* timestamp) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_);
  }
  timestamp_ = timestamp;
  if (timestamp) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.StatePoint.timestamp)
}
inline ::osi3::Timestamp* StatePoint::release_timestamp() {
  
  ::osi3::Timestamp* temp = timestamp_;
  timestamp_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Timestamp* StatePoint::unsafe_arena_release_timestamp() {
  // @@protoc_insertion_point(field_release:osi3.StatePoint.timestamp)
  
  ::osi3::Timestamp* temp = timestamp_;
  timestamp_ = nullptr;
  return temp;
}
inline ::osi3::Timestamp* StatePoint::_internal_mutable_timestamp() {
  
  if (timestamp_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Timestamp>(GetArena());
    timestamp_ = p;
  }
  return timestamp_;
}
inline ::osi3::Timestamp* StatePoint::mutable_timestamp() {
  // @@protoc_insertion_point(field_mutable:osi3.StatePoint.timestamp)
  return _internal_mutable_timestamp();
}
inline void StatePoint::set_allocated_timestamp(::osi3::Timestamp* timestamp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete timestamp_;
  }
  if (timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp);
    if (message_arena != submessage_arena) {
      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timestamp, submessage_arena);
    }
    
  } else {
    
  }
  timestamp_ = timestamp;
  // @@protoc_insertion_point(field_set_allocated:osi3.StatePoint.timestamp)
}

// .osi3.Vector3d position = 2;
inline bool StatePoint::_internal_has_position() const {
  return this != internal_default_instance() && position_ != nullptr;
}
inline bool StatePoint::has_position() const {
  return _internal_has_position();
}
inline void StatePoint::clear_position() {
  if (GetArena() == nullptr && position_ != nullptr) {
    delete position_;
  }
  position_ = nullptr;
}
inline const ::osi3::Vector3d& StatePoint::_internal_position() const {
  const ::osi3::Vector3d* p = position_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Vector3d&>(
      ::osi3::_Vector3d_default_instance_);
}
inline const ::osi3::Vector3d& StatePoint::position() const {
  // @@protoc_insertion_point(field_get:osi3.StatePoint.position)
  return _internal_position();
}
inline void StatePoint::unsafe_arena_set_allocated_position(
    ::osi3::Vector3d* position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(position_);
  }
  position_ = position;
  if (position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.StatePoint.position)
}
inline ::osi3::Vector3d* StatePoint::release_position() {
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Vector3d* StatePoint::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:osi3.StatePoint.position)
  
  ::osi3::Vector3d* temp = position_;
  position_ = nullptr;
  return temp;
}
inline ::osi3::Vector3d* StatePoint::_internal_mutable_position() {
  
  if (position_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Vector3d>(GetArena());
    position_ = p;
  }
  return position_;
}
inline ::osi3::Vector3d* StatePoint::mutable_position() {
  // @@protoc_insertion_point(field_mutable:osi3.StatePoint.position)
  return _internal_mutable_position();
}
inline void StatePoint::set_allocated_position(::osi3::Vector3d* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete position_;
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    
  } else {
    
  }
  position_ = position;
  // @@protoc_insertion_point(field_set_allocated:osi3.StatePoint.position)
}

// .osi3.Orientation3d orientation = 3;
inline bool StatePoint::_internal_has_orientation() const {
  return this != internal_default_instance() && orientation_ != nullptr;
}
inline bool StatePoint::has_orientation() const {
  return _internal_has_orientation();
}
inline void StatePoint::clear_orientation() {
  if (GetArena() == nullptr && orientation_ != nullptr) {
    delete orientation_;
  }
  orientation_ = nullptr;
}
inline const ::osi3::Orientation3d& StatePoint::_internal_orientation() const {
  const ::osi3::Orientation3d* p = orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Orientation3d&>(
      ::osi3::_Orientation3d_default_instance_);
}
inline const ::osi3::Orientation3d& StatePoint::orientation() const {
  // @@protoc_insertion_point(field_get:osi3.StatePoint.orientation)
  return _internal_orientation();
}
inline void StatePoint::unsafe_arena_set_allocated_orientation(
    ::osi3::Orientation3d* orientation) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(orientation_);
  }
  orientation_ = orientation;
  if (orientation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.StatePoint.orientation)
}
inline ::osi3::Orientation3d* StatePoint::release_orientation() {
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Orientation3d* StatePoint::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:osi3.StatePoint.orientation)
  
  ::osi3::Orientation3d* temp = orientation_;
  orientation_ = nullptr;
  return temp;
}
inline ::osi3::Orientation3d* StatePoint::_internal_mutable_orientation() {
  
  if (orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Orientation3d>(GetArena());
    orientation_ = p;
  }
  return orientation_;
}
inline ::osi3::Orientation3d* StatePoint::mutable_orientation() {
  // @@protoc_insertion_point(field_mutable:osi3.StatePoint.orientation)
  return _internal_mutable_orientation();
}
inline void StatePoint::set_allocated_orientation(::osi3::Orientation3d* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete orientation_;
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(orientation);
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    
  } else {
    
  }
  orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:osi3.StatePoint.orientation)
}

// -------------------------------------------------------------------

// WavelengthData

// double start = 1;
inline void WavelengthData::clear_start() {
  start_ = 0;
}
inline double WavelengthData::_internal_start() const {
  return start_;
}
inline double WavelengthData::start() const {
  // @@protoc_insertion_point(field_get:osi3.WavelengthData.start)
  return _internal_start();
}
inline void WavelengthData::_internal_set_start(double value) {
  
  start_ = value;
}
inline void WavelengthData::set_start(double value) {
  _internal_set_start(value);
  // @@protoc_insertion_point(field_set:osi3.WavelengthData.start)
}

// double end = 2;
inline void WavelengthData::clear_end() {
  end_ = 0;
}
inline double WavelengthData::_internal_end() const {
  return end_;
}
inline double WavelengthData::end() const {
  // @@protoc_insertion_point(field_get:osi3.WavelengthData.end)
  return _internal_end();
}
inline void WavelengthData::_internal_set_end(double value) {
  
  end_ = value;
}
inline void WavelengthData::set_end(double value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:osi3.WavelengthData.end)
}

// double samples_number = 3;
inline void WavelengthData::clear_samples_number() {
  samples_number_ = 0;
}
inline double WavelengthData::_internal_samples_number() const {
  return samples_number_;
}
inline double WavelengthData::samples_number() const {
  // @@protoc_insertion_point(field_get:osi3.WavelengthData.samples_number)
  return _internal_samples_number();
}
inline void WavelengthData::_internal_set_samples_number(double value) {
  
  samples_number_ = value;
}
inline void WavelengthData::set_samples_number(double value) {
  _internal_set_samples_number(value);
  // @@protoc_insertion_point(field_set:osi3.WavelengthData.samples_number)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace osi3

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_osi_5fcommon_2eproto
