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

#ifndef GOOGLE_PROTOBUF_INCLUDED_osi_5fsensordata_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_osi_5fsensordata_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "osi_version.pb.h"
#include "osi_common.pb.h"
#include "osi_detectedtrafficsign.pb.h"
#include "osi_detectedtrafficlight.pb.h"
#include "osi_detectedroadmarking.pb.h"
#include "osi_detectedlane.pb.h"
#include "osi_detectedobject.pb.h"
#include "osi_detectedoccupant.pb.h"
#include "osi_sensorview.pb.h"
#include "osi_featuredata.pb.h"
#include "osi_logicaldetectiondata.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_osi_5fsensordata_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_osi_5fsensordata_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[2]
    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_5fsensordata_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_osi_5fsensordata_2eproto_metadata_getter(int index);
namespace osi3 {
class DetectedEntityHeader;
struct DetectedEntityHeaderDefaultTypeInternal;
extern DetectedEntityHeaderDefaultTypeInternal _DetectedEntityHeader_default_instance_;
class SensorData;
struct SensorDataDefaultTypeInternal;
extern SensorDataDefaultTypeInternal _SensorData_default_instance_;
}  // namespace osi3
PROTOBUF_NAMESPACE_OPEN
template<> ::osi3::DetectedEntityHeader* Arena::CreateMaybeMessage<::osi3::DetectedEntityHeader>(Arena*);
template<> ::osi3::SensorData* Arena::CreateMaybeMessage<::osi3::SensorData>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace osi3 {

enum DetectedEntityHeader_DataQualifier : int {
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_UNKNOWN = 0,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_OTHER = 1,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_AVAILABLE = 2,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_AVAILABLE_REDUCED = 3,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_NOT_AVAILABLE = 4,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_BLINDNESS = 5,
  DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_TEMPORARY_AVAILABLE = 6,
  DetectedEntityHeader_DataQualifier_DetectedEntityHeader_DataQualifier_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DetectedEntityHeader_DataQualifier_DetectedEntityHeader_DataQualifier_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DetectedEntityHeader_DataQualifier_IsValid(int value);
constexpr DetectedEntityHeader_DataQualifier DetectedEntityHeader_DataQualifier_DataQualifier_MIN = DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_UNKNOWN;
constexpr DetectedEntityHeader_DataQualifier DetectedEntityHeader_DataQualifier_DataQualifier_MAX = DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_TEMPORARY_AVAILABLE;
constexpr int DetectedEntityHeader_DataQualifier_DataQualifier_ARRAYSIZE = DetectedEntityHeader_DataQualifier_DataQualifier_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DetectedEntityHeader_DataQualifier_descriptor();
template<typename T>
inline const std::string& DetectedEntityHeader_DataQualifier_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DetectedEntityHeader_DataQualifier>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DetectedEntityHeader_DataQualifier_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DetectedEntityHeader_DataQualifier_descriptor(), enum_t_value);
}
inline bool DetectedEntityHeader_DataQualifier_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DetectedEntityHeader_DataQualifier* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DetectedEntityHeader_DataQualifier>(
    DetectedEntityHeader_DataQualifier_descriptor(), name, value);
}
// ===================================================================

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

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

  inline DetectedEntityHeader& operator=(const DetectedEntityHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline DetectedEntityHeader& operator=(DetectedEntityHeader&& 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 DetectedEntityHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const DetectedEntityHeader* internal_default_instance() {
    return reinterpret_cast<const DetectedEntityHeader*>(
               &_DetectedEntityHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  DetectedEntityHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DetectedEntityHeader>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DetectedEntityHeader& from);
  void MergeFrom(const DetectedEntityHeader& 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(DetectedEntityHeader* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.DetectedEntityHeader";
  }
  protected:
  explicit DetectedEntityHeader(::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_5fsensordata_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

  typedef DetectedEntityHeader_DataQualifier DataQualifier;
  static constexpr DataQualifier DATA_QUALIFIER_UNKNOWN =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_UNKNOWN;
  static constexpr DataQualifier DATA_QUALIFIER_OTHER =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_OTHER;
  static constexpr DataQualifier DATA_QUALIFIER_AVAILABLE =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_AVAILABLE;
  static constexpr DataQualifier DATA_QUALIFIER_AVAILABLE_REDUCED =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_AVAILABLE_REDUCED;
  static constexpr DataQualifier DATA_QUALIFIER_NOT_AVAILABLE =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_NOT_AVAILABLE;
  static constexpr DataQualifier DATA_QUALIFIER_BLINDNESS =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_BLINDNESS;
  static constexpr DataQualifier DATA_QUALIFIER_TEMPORARY_AVAILABLE =
    DetectedEntityHeader_DataQualifier_DATA_QUALIFIER_TEMPORARY_AVAILABLE;
  static inline bool DataQualifier_IsValid(int value) {
    return DetectedEntityHeader_DataQualifier_IsValid(value);
  }
  static constexpr DataQualifier DataQualifier_MIN =
    DetectedEntityHeader_DataQualifier_DataQualifier_MIN;
  static constexpr DataQualifier DataQualifier_MAX =
    DetectedEntityHeader_DataQualifier_DataQualifier_MAX;
  static constexpr int DataQualifier_ARRAYSIZE =
    DetectedEntityHeader_DataQualifier_DataQualifier_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DataQualifier_descriptor() {
    return DetectedEntityHeader_DataQualifier_descriptor();
  }
  template<typename T>
  static inline const std::string& DataQualifier_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DataQualifier>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DataQualifier_Name.");
    return DetectedEntityHeader_DataQualifier_Name(enum_t_value);
  }
  static inline bool DataQualifier_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DataQualifier* value) {
    return DetectedEntityHeader_DataQualifier_Parse(name, value);
  }

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

  enum : int {
    kMeasurementTimeFieldNumber = 1,
    kCycleCounterFieldNumber = 2,
    kDataQualifierFieldNumber = 3,
  };
  // .osi3.Timestamp measurement_time = 1;
  bool has_measurement_time() const;
  private:
  bool _internal_has_measurement_time() const;
  public:
  void clear_measurement_time();
  const ::osi3::Timestamp& measurement_time() const;
  ::osi3::Timestamp* release_measurement_time();
  ::osi3::Timestamp* mutable_measurement_time();
  void set_allocated_measurement_time(::osi3::Timestamp* measurement_time);
  private:
  const ::osi3::Timestamp& _internal_measurement_time() const;
  ::osi3::Timestamp* _internal_mutable_measurement_time();
  public:
  void unsafe_arena_set_allocated_measurement_time(
      ::osi3::Timestamp* measurement_time);
  ::osi3::Timestamp* unsafe_arena_release_measurement_time();

  // uint64 cycle_counter = 2;
  void clear_cycle_counter();
  ::PROTOBUF_NAMESPACE_ID::uint64 cycle_counter() const;
  void set_cycle_counter(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_cycle_counter() const;
  void _internal_set_cycle_counter(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // .osi3.DetectedEntityHeader.DataQualifier data_qualifier = 3;
  void clear_data_qualifier();
  ::osi3::DetectedEntityHeader_DataQualifier data_qualifier() const;
  void set_data_qualifier(::osi3::DetectedEntityHeader_DataQualifier value);
  private:
  ::osi3::DetectedEntityHeader_DataQualifier _internal_data_qualifier() const;
  void _internal_set_data_qualifier(::osi3::DetectedEntityHeader_DataQualifier value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Timestamp* measurement_time_;
  ::PROTOBUF_NAMESPACE_ID::uint64 cycle_counter_;
  int data_qualifier_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fsensordata_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SensorData& operator=(const SensorData& from) {
    CopyFrom(from);
    return *this;
  }
  inline SensorData& operator=(SensorData&& 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 SensorData& default_instance() {
    return *internal_default_instance();
  }
  static inline const SensorData* internal_default_instance() {
    return reinterpret_cast<const SensorData*>(
               &_SensorData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  SensorData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SensorData>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SensorData& from);
  void MergeFrom(const SensorData& 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(SensorData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "osi3.SensorData";
  }
  protected:
  explicit SensorData(::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_5fsensordata_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kSensorViewFieldNumber = 8,
    kStationaryObjectFieldNumber = 11,
    kMovingObjectFieldNumber = 13,
    kTrafficSignFieldNumber = 15,
    kTrafficLightFieldNumber = 17,
    kRoadMarkingFieldNumber = 19,
    kLaneBoundaryFieldNumber = 21,
    kLaneFieldNumber = 23,
    kOccupantFieldNumber = 25,
    kVersionFieldNumber = 1,
    kTimestampFieldNumber = 2,
    kHostVehicleLocationFieldNumber = 3,
    kHostVehicleLocationRmseFieldNumber = 4,
    kSensorIdFieldNumber = 5,
    kMountingPositionFieldNumber = 6,
    kMountingPositionRmseFieldNumber = 7,
    kLastMeasurementTimeFieldNumber = 9,
    kStationaryObjectHeaderFieldNumber = 10,
    kMovingObjectHeaderFieldNumber = 12,
    kTrafficSignHeaderFieldNumber = 14,
    kTrafficLightHeaderFieldNumber = 16,
    kRoadMarkingHeaderFieldNumber = 18,
    kLaneBoundaryHeaderFieldNumber = 20,
    kLaneHeaderFieldNumber = 22,
    kOccupantHeaderFieldNumber = 24,
    kFeatureDataFieldNumber = 26,
    kLogicalDetectionDataFieldNumber = 27,
  };
  // repeated .osi3.SensorView sensor_view = 8;
  int sensor_view_size() const;
  private:
  int _internal_sensor_view_size() const;
  public:
  void clear_sensor_view();
  ::osi3::SensorView* mutable_sensor_view(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::SensorView >*
      mutable_sensor_view();
  private:
  const ::osi3::SensorView& _internal_sensor_view(int index) const;
  ::osi3::SensorView* _internal_add_sensor_view();
  public:
  const ::osi3::SensorView& sensor_view(int index) const;
  ::osi3::SensorView* add_sensor_view();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::SensorView >&
      sensor_view() const;

  // repeated .osi3.DetectedStationaryObject stationary_object = 11;
  int stationary_object_size() const;
  private:
  int _internal_stationary_object_size() const;
  public:
  void clear_stationary_object();
  ::osi3::DetectedStationaryObject* mutable_stationary_object(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedStationaryObject >*
      mutable_stationary_object();
  private:
  const ::osi3::DetectedStationaryObject& _internal_stationary_object(int index) const;
  ::osi3::DetectedStationaryObject* _internal_add_stationary_object();
  public:
  const ::osi3::DetectedStationaryObject& stationary_object(int index) const;
  ::osi3::DetectedStationaryObject* add_stationary_object();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedStationaryObject >&
      stationary_object() const;

  // repeated .osi3.DetectedMovingObject moving_object = 13;
  int moving_object_size() const;
  private:
  int _internal_moving_object_size() const;
  public:
  void clear_moving_object();
  ::osi3::DetectedMovingObject* mutable_moving_object(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedMovingObject >*
      mutable_moving_object();
  private:
  const ::osi3::DetectedMovingObject& _internal_moving_object(int index) const;
  ::osi3::DetectedMovingObject* _internal_add_moving_object();
  public:
  const ::osi3::DetectedMovingObject& moving_object(int index) const;
  ::osi3::DetectedMovingObject* add_moving_object();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedMovingObject >&
      moving_object() const;

  // repeated .osi3.DetectedTrafficSign traffic_sign = 15;
  int traffic_sign_size() const;
  private:
  int _internal_traffic_sign_size() const;
  public:
  void clear_traffic_sign();
  ::osi3::DetectedTrafficSign* mutable_traffic_sign(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficSign >*
      mutable_traffic_sign();
  private:
  const ::osi3::DetectedTrafficSign& _internal_traffic_sign(int index) const;
  ::osi3::DetectedTrafficSign* _internal_add_traffic_sign();
  public:
  const ::osi3::DetectedTrafficSign& traffic_sign(int index) const;
  ::osi3::DetectedTrafficSign* add_traffic_sign();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficSign >&
      traffic_sign() const;

  // repeated .osi3.DetectedTrafficLight traffic_light = 17;
  int traffic_light_size() const;
  private:
  int _internal_traffic_light_size() const;
  public:
  void clear_traffic_light();
  ::osi3::DetectedTrafficLight* mutable_traffic_light(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficLight >*
      mutable_traffic_light();
  private:
  const ::osi3::DetectedTrafficLight& _internal_traffic_light(int index) const;
  ::osi3::DetectedTrafficLight* _internal_add_traffic_light();
  public:
  const ::osi3::DetectedTrafficLight& traffic_light(int index) const;
  ::osi3::DetectedTrafficLight* add_traffic_light();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficLight >&
      traffic_light() const;

  // repeated .osi3.DetectedRoadMarking road_marking = 19;
  int road_marking_size() const;
  private:
  int _internal_road_marking_size() const;
  public:
  void clear_road_marking();
  ::osi3::DetectedRoadMarking* mutable_road_marking(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedRoadMarking >*
      mutable_road_marking();
  private:
  const ::osi3::DetectedRoadMarking& _internal_road_marking(int index) const;
  ::osi3::DetectedRoadMarking* _internal_add_road_marking();
  public:
  const ::osi3::DetectedRoadMarking& road_marking(int index) const;
  ::osi3::DetectedRoadMarking* add_road_marking();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedRoadMarking >&
      road_marking() const;

  // repeated .osi3.DetectedLaneBoundary lane_boundary = 21;
  int lane_boundary_size() const;
  private:
  int _internal_lane_boundary_size() const;
  public:
  void clear_lane_boundary();
  ::osi3::DetectedLaneBoundary* mutable_lane_boundary(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLaneBoundary >*
      mutable_lane_boundary();
  private:
  const ::osi3::DetectedLaneBoundary& _internal_lane_boundary(int index) const;
  ::osi3::DetectedLaneBoundary* _internal_add_lane_boundary();
  public:
  const ::osi3::DetectedLaneBoundary& lane_boundary(int index) const;
  ::osi3::DetectedLaneBoundary* add_lane_boundary();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLaneBoundary >&
      lane_boundary() const;

  // repeated .osi3.DetectedLane lane = 23;
  int lane_size() const;
  private:
  int _internal_lane_size() const;
  public:
  void clear_lane();
  ::osi3::DetectedLane* mutable_lane(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLane >*
      mutable_lane();
  private:
  const ::osi3::DetectedLane& _internal_lane(int index) const;
  ::osi3::DetectedLane* _internal_add_lane();
  public:
  const ::osi3::DetectedLane& lane(int index) const;
  ::osi3::DetectedLane* add_lane();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLane >&
      lane() const;

  // repeated .osi3.DetectedOccupant occupant = 25;
  int occupant_size() const;
  private:
  int _internal_occupant_size() const;
  public:
  void clear_occupant();
  ::osi3::DetectedOccupant* mutable_occupant(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedOccupant >*
      mutable_occupant();
  private:
  const ::osi3::DetectedOccupant& _internal_occupant(int index) const;
  ::osi3::DetectedOccupant* _internal_add_occupant();
  public:
  const ::osi3::DetectedOccupant& occupant(int index) const;
  ::osi3::DetectedOccupant* add_occupant();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedOccupant >&
      occupant() const;

  // .osi3.InterfaceVersion version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const ::osi3::InterfaceVersion& version() const;
  ::osi3::InterfaceVersion* release_version();
  ::osi3::InterfaceVersion* mutable_version();
  void set_allocated_version(::osi3::InterfaceVersion* version);
  private:
  const ::osi3::InterfaceVersion& _internal_version() const;
  ::osi3::InterfaceVersion* _internal_mutable_version();
  public:
  void unsafe_arena_set_allocated_version(
      ::osi3::InterfaceVersion* version);
  ::osi3::InterfaceVersion* unsafe_arena_release_version();

  // .osi3.Timestamp timestamp = 2;
  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.BaseMoving host_vehicle_location = 3;
  bool has_host_vehicle_location() const;
  private:
  bool _internal_has_host_vehicle_location() const;
  public:
  void clear_host_vehicle_location();
  const ::osi3::BaseMoving& host_vehicle_location() const;
  ::osi3::BaseMoving* release_host_vehicle_location();
  ::osi3::BaseMoving* mutable_host_vehicle_location();
  void set_allocated_host_vehicle_location(::osi3::BaseMoving* host_vehicle_location);
  private:
  const ::osi3::BaseMoving& _internal_host_vehicle_location() const;
  ::osi3::BaseMoving* _internal_mutable_host_vehicle_location();
  public:
  void unsafe_arena_set_allocated_host_vehicle_location(
      ::osi3::BaseMoving* host_vehicle_location);
  ::osi3::BaseMoving* unsafe_arena_release_host_vehicle_location();

  // .osi3.BaseMoving host_vehicle_location_rmse = 4;
  bool has_host_vehicle_location_rmse() const;
  private:
  bool _internal_has_host_vehicle_location_rmse() const;
  public:
  void clear_host_vehicle_location_rmse();
  const ::osi3::BaseMoving& host_vehicle_location_rmse() const;
  ::osi3::BaseMoving* release_host_vehicle_location_rmse();
  ::osi3::BaseMoving* mutable_host_vehicle_location_rmse();
  void set_allocated_host_vehicle_location_rmse(::osi3::BaseMoving* host_vehicle_location_rmse);
  private:
  const ::osi3::BaseMoving& _internal_host_vehicle_location_rmse() const;
  ::osi3::BaseMoving* _internal_mutable_host_vehicle_location_rmse();
  public:
  void unsafe_arena_set_allocated_host_vehicle_location_rmse(
      ::osi3::BaseMoving* host_vehicle_location_rmse);
  ::osi3::BaseMoving* unsafe_arena_release_host_vehicle_location_rmse();

  // .osi3.Identifier sensor_id = 5;
  bool has_sensor_id() const;
  private:
  bool _internal_has_sensor_id() const;
  public:
  void clear_sensor_id();
  const ::osi3::Identifier& sensor_id() const;
  ::osi3::Identifier* release_sensor_id();
  ::osi3::Identifier* mutable_sensor_id();
  void set_allocated_sensor_id(::osi3::Identifier* sensor_id);
  private:
  const ::osi3::Identifier& _internal_sensor_id() const;
  ::osi3::Identifier* _internal_mutable_sensor_id();
  public:
  void unsafe_arena_set_allocated_sensor_id(
      ::osi3::Identifier* sensor_id);
  ::osi3::Identifier* unsafe_arena_release_sensor_id();

  // .osi3.MountingPosition mounting_position = 6;
  bool has_mounting_position() const;
  private:
  bool _internal_has_mounting_position() const;
  public:
  void clear_mounting_position();
  const ::osi3::MountingPosition& mounting_position() const;
  ::osi3::MountingPosition* release_mounting_position();
  ::osi3::MountingPosition* mutable_mounting_position();
  void set_allocated_mounting_position(::osi3::MountingPosition* mounting_position);
  private:
  const ::osi3::MountingPosition& _internal_mounting_position() const;
  ::osi3::MountingPosition* _internal_mutable_mounting_position();
  public:
  void unsafe_arena_set_allocated_mounting_position(
      ::osi3::MountingPosition* mounting_position);
  ::osi3::MountingPosition* unsafe_arena_release_mounting_position();

  // .osi3.MountingPosition mounting_position_rmse = 7;
  bool has_mounting_position_rmse() const;
  private:
  bool _internal_has_mounting_position_rmse() const;
  public:
  void clear_mounting_position_rmse();
  const ::osi3::MountingPosition& mounting_position_rmse() const;
  ::osi3::MountingPosition* release_mounting_position_rmse();
  ::osi3::MountingPosition* mutable_mounting_position_rmse();
  void set_allocated_mounting_position_rmse(::osi3::MountingPosition* mounting_position_rmse);
  private:
  const ::osi3::MountingPosition& _internal_mounting_position_rmse() const;
  ::osi3::MountingPosition* _internal_mutable_mounting_position_rmse();
  public:
  void unsafe_arena_set_allocated_mounting_position_rmse(
      ::osi3::MountingPosition* mounting_position_rmse);
  ::osi3::MountingPosition* unsafe_arena_release_mounting_position_rmse();

  // .osi3.Timestamp last_measurement_time = 9;
  bool has_last_measurement_time() const;
  private:
  bool _internal_has_last_measurement_time() const;
  public:
  void clear_last_measurement_time();
  const ::osi3::Timestamp& last_measurement_time() const;
  ::osi3::Timestamp* release_last_measurement_time();
  ::osi3::Timestamp* mutable_last_measurement_time();
  void set_allocated_last_measurement_time(::osi3::Timestamp* last_measurement_time);
  private:
  const ::osi3::Timestamp& _internal_last_measurement_time() const;
  ::osi3::Timestamp* _internal_mutable_last_measurement_time();
  public:
  void unsafe_arena_set_allocated_last_measurement_time(
      ::osi3::Timestamp* last_measurement_time);
  ::osi3::Timestamp* unsafe_arena_release_last_measurement_time();

  // .osi3.DetectedEntityHeader stationary_object_header = 10;
  bool has_stationary_object_header() const;
  private:
  bool _internal_has_stationary_object_header() const;
  public:
  void clear_stationary_object_header();
  const ::osi3::DetectedEntityHeader& stationary_object_header() const;
  ::osi3::DetectedEntityHeader* release_stationary_object_header();
  ::osi3::DetectedEntityHeader* mutable_stationary_object_header();
  void set_allocated_stationary_object_header(::osi3::DetectedEntityHeader* stationary_object_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_stationary_object_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_stationary_object_header();
  public:
  void unsafe_arena_set_allocated_stationary_object_header(
      ::osi3::DetectedEntityHeader* stationary_object_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_stationary_object_header();

  // .osi3.DetectedEntityHeader moving_object_header = 12;
  bool has_moving_object_header() const;
  private:
  bool _internal_has_moving_object_header() const;
  public:
  void clear_moving_object_header();
  const ::osi3::DetectedEntityHeader& moving_object_header() const;
  ::osi3::DetectedEntityHeader* release_moving_object_header();
  ::osi3::DetectedEntityHeader* mutable_moving_object_header();
  void set_allocated_moving_object_header(::osi3::DetectedEntityHeader* moving_object_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_moving_object_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_moving_object_header();
  public:
  void unsafe_arena_set_allocated_moving_object_header(
      ::osi3::DetectedEntityHeader* moving_object_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_moving_object_header();

  // .osi3.DetectedEntityHeader traffic_sign_header = 14;
  bool has_traffic_sign_header() const;
  private:
  bool _internal_has_traffic_sign_header() const;
  public:
  void clear_traffic_sign_header();
  const ::osi3::DetectedEntityHeader& traffic_sign_header() const;
  ::osi3::DetectedEntityHeader* release_traffic_sign_header();
  ::osi3::DetectedEntityHeader* mutable_traffic_sign_header();
  void set_allocated_traffic_sign_header(::osi3::DetectedEntityHeader* traffic_sign_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_traffic_sign_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_traffic_sign_header();
  public:
  void unsafe_arena_set_allocated_traffic_sign_header(
      ::osi3::DetectedEntityHeader* traffic_sign_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_traffic_sign_header();

  // .osi3.DetectedEntityHeader traffic_light_header = 16;
  bool has_traffic_light_header() const;
  private:
  bool _internal_has_traffic_light_header() const;
  public:
  void clear_traffic_light_header();
  const ::osi3::DetectedEntityHeader& traffic_light_header() const;
  ::osi3::DetectedEntityHeader* release_traffic_light_header();
  ::osi3::DetectedEntityHeader* mutable_traffic_light_header();
  void set_allocated_traffic_light_header(::osi3::DetectedEntityHeader* traffic_light_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_traffic_light_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_traffic_light_header();
  public:
  void unsafe_arena_set_allocated_traffic_light_header(
      ::osi3::DetectedEntityHeader* traffic_light_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_traffic_light_header();

  // .osi3.DetectedEntityHeader road_marking_header = 18;
  bool has_road_marking_header() const;
  private:
  bool _internal_has_road_marking_header() const;
  public:
  void clear_road_marking_header();
  const ::osi3::DetectedEntityHeader& road_marking_header() const;
  ::osi3::DetectedEntityHeader* release_road_marking_header();
  ::osi3::DetectedEntityHeader* mutable_road_marking_header();
  void set_allocated_road_marking_header(::osi3::DetectedEntityHeader* road_marking_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_road_marking_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_road_marking_header();
  public:
  void unsafe_arena_set_allocated_road_marking_header(
      ::osi3::DetectedEntityHeader* road_marking_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_road_marking_header();

  // .osi3.DetectedEntityHeader lane_boundary_header = 20;
  bool has_lane_boundary_header() const;
  private:
  bool _internal_has_lane_boundary_header() const;
  public:
  void clear_lane_boundary_header();
  const ::osi3::DetectedEntityHeader& lane_boundary_header() const;
  ::osi3::DetectedEntityHeader* release_lane_boundary_header();
  ::osi3::DetectedEntityHeader* mutable_lane_boundary_header();
  void set_allocated_lane_boundary_header(::osi3::DetectedEntityHeader* lane_boundary_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_lane_boundary_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_lane_boundary_header();
  public:
  void unsafe_arena_set_allocated_lane_boundary_header(
      ::osi3::DetectedEntityHeader* lane_boundary_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_lane_boundary_header();

  // .osi3.DetectedEntityHeader lane_header = 22;
  bool has_lane_header() const;
  private:
  bool _internal_has_lane_header() const;
  public:
  void clear_lane_header();
  const ::osi3::DetectedEntityHeader& lane_header() const;
  ::osi3::DetectedEntityHeader* release_lane_header();
  ::osi3::DetectedEntityHeader* mutable_lane_header();
  void set_allocated_lane_header(::osi3::DetectedEntityHeader* lane_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_lane_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_lane_header();
  public:
  void unsafe_arena_set_allocated_lane_header(
      ::osi3::DetectedEntityHeader* lane_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_lane_header();

  // .osi3.DetectedEntityHeader occupant_header = 24;
  bool has_occupant_header() const;
  private:
  bool _internal_has_occupant_header() const;
  public:
  void clear_occupant_header();
  const ::osi3::DetectedEntityHeader& occupant_header() const;
  ::osi3::DetectedEntityHeader* release_occupant_header();
  ::osi3::DetectedEntityHeader* mutable_occupant_header();
  void set_allocated_occupant_header(::osi3::DetectedEntityHeader* occupant_header);
  private:
  const ::osi3::DetectedEntityHeader& _internal_occupant_header() const;
  ::osi3::DetectedEntityHeader* _internal_mutable_occupant_header();
  public:
  void unsafe_arena_set_allocated_occupant_header(
      ::osi3::DetectedEntityHeader* occupant_header);
  ::osi3::DetectedEntityHeader* unsafe_arena_release_occupant_header();

  // .osi3.FeatureData feature_data = 26;
  bool has_feature_data() const;
  private:
  bool _internal_has_feature_data() const;
  public:
  void clear_feature_data();
  const ::osi3::FeatureData& feature_data() const;
  ::osi3::FeatureData* release_feature_data();
  ::osi3::FeatureData* mutable_feature_data();
  void set_allocated_feature_data(::osi3::FeatureData* feature_data);
  private:
  const ::osi3::FeatureData& _internal_feature_data() const;
  ::osi3::FeatureData* _internal_mutable_feature_data();
  public:
  void unsafe_arena_set_allocated_feature_data(
      ::osi3::FeatureData* feature_data);
  ::osi3::FeatureData* unsafe_arena_release_feature_data();

  // .osi3.LogicalDetectionData logical_detection_data = 27;
  bool has_logical_detection_data() const;
  private:
  bool _internal_has_logical_detection_data() const;
  public:
  void clear_logical_detection_data();
  const ::osi3::LogicalDetectionData& logical_detection_data() const;
  ::osi3::LogicalDetectionData* release_logical_detection_data();
  ::osi3::LogicalDetectionData* mutable_logical_detection_data();
  void set_allocated_logical_detection_data(::osi3::LogicalDetectionData* logical_detection_data);
  private:
  const ::osi3::LogicalDetectionData& _internal_logical_detection_data() const;
  ::osi3::LogicalDetectionData* _internal_mutable_logical_detection_data();
  public:
  void unsafe_arena_set_allocated_logical_detection_data(
      ::osi3::LogicalDetectionData* logical_detection_data);
  ::osi3::LogicalDetectionData* unsafe_arena_release_logical_detection_data();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::SensorView > sensor_view_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedStationaryObject > stationary_object_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedMovingObject > moving_object_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficSign > traffic_sign_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficLight > traffic_light_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedRoadMarking > road_marking_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLaneBoundary > lane_boundary_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLane > lane_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedOccupant > occupant_;
  ::osi3::InterfaceVersion* version_;
  ::osi3::Timestamp* timestamp_;
  ::osi3::BaseMoving* host_vehicle_location_;
  ::osi3::BaseMoving* host_vehicle_location_rmse_;
  ::osi3::Identifier* sensor_id_;
  ::osi3::MountingPosition* mounting_position_;
  ::osi3::MountingPosition* mounting_position_rmse_;
  ::osi3::Timestamp* last_measurement_time_;
  ::osi3::DetectedEntityHeader* stationary_object_header_;
  ::osi3::DetectedEntityHeader* moving_object_header_;
  ::osi3::DetectedEntityHeader* traffic_sign_header_;
  ::osi3::DetectedEntityHeader* traffic_light_header_;
  ::osi3::DetectedEntityHeader* road_marking_header_;
  ::osi3::DetectedEntityHeader* lane_boundary_header_;
  ::osi3::DetectedEntityHeader* lane_header_;
  ::osi3::DetectedEntityHeader* occupant_header_;
  ::osi3::FeatureData* feature_data_;
  ::osi3::LogicalDetectionData* logical_detection_data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5fsensordata_2eproto;
};
// ===================================================================


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

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

// .osi3.Timestamp measurement_time = 1;
inline bool DetectedEntityHeader::_internal_has_measurement_time() const {
  return this != internal_default_instance() && measurement_time_ != nullptr;
}
inline bool DetectedEntityHeader::has_measurement_time() const {
  return _internal_has_measurement_time();
}
inline const ::osi3::Timestamp& DetectedEntityHeader::_internal_measurement_time() const {
  const ::osi3::Timestamp* p = measurement_time_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Timestamp&>(
      ::osi3::_Timestamp_default_instance_);
}
inline const ::osi3::Timestamp& DetectedEntityHeader::measurement_time() const {
  // @@protoc_insertion_point(field_get:osi3.DetectedEntityHeader.measurement_time)
  return _internal_measurement_time();
}
inline void DetectedEntityHeader::unsafe_arena_set_allocated_measurement_time(
    ::osi3::Timestamp* measurement_time) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measurement_time_);
  }
  measurement_time_ = measurement_time;
  if (measurement_time) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.DetectedEntityHeader.measurement_time)
}
inline ::osi3::Timestamp* DetectedEntityHeader::release_measurement_time() {
  
  ::osi3::Timestamp* temp = measurement_time_;
  measurement_time_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Timestamp* DetectedEntityHeader::unsafe_arena_release_measurement_time() {
  // @@protoc_insertion_point(field_release:osi3.DetectedEntityHeader.measurement_time)
  
  ::osi3::Timestamp* temp = measurement_time_;
  measurement_time_ = nullptr;
  return temp;
}
inline ::osi3::Timestamp* DetectedEntityHeader::_internal_mutable_measurement_time() {
  
  if (measurement_time_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Timestamp>(GetArena());
    measurement_time_ = p;
  }
  return measurement_time_;
}
inline ::osi3::Timestamp* DetectedEntityHeader::mutable_measurement_time() {
  // @@protoc_insertion_point(field_mutable:osi3.DetectedEntityHeader.measurement_time)
  return _internal_mutable_measurement_time();
}
inline void DetectedEntityHeader::set_allocated_measurement_time(::osi3::Timestamp* measurement_time) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measurement_time_);
  }
  if (measurement_time) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measurement_time)->GetArena();
    if (message_arena != submessage_arena) {
      measurement_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, measurement_time, submessage_arena);
    }
    
  } else {
    
  }
  measurement_time_ = measurement_time;
  // @@protoc_insertion_point(field_set_allocated:osi3.DetectedEntityHeader.measurement_time)
}

// uint64 cycle_counter = 2;
inline void DetectedEntityHeader::clear_cycle_counter() {
  cycle_counter_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 DetectedEntityHeader::_internal_cycle_counter() const {
  return cycle_counter_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 DetectedEntityHeader::cycle_counter() const {
  // @@protoc_insertion_point(field_get:osi3.DetectedEntityHeader.cycle_counter)
  return _internal_cycle_counter();
}
inline void DetectedEntityHeader::_internal_set_cycle_counter(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  cycle_counter_ = value;
}
inline void DetectedEntityHeader::set_cycle_counter(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_cycle_counter(value);
  // @@protoc_insertion_point(field_set:osi3.DetectedEntityHeader.cycle_counter)
}

// .osi3.DetectedEntityHeader.DataQualifier data_qualifier = 3;
inline void DetectedEntityHeader::clear_data_qualifier() {
  data_qualifier_ = 0;
}
inline ::osi3::DetectedEntityHeader_DataQualifier DetectedEntityHeader::_internal_data_qualifier() const {
  return static_cast< ::osi3::DetectedEntityHeader_DataQualifier >(data_qualifier_);
}
inline ::osi3::DetectedEntityHeader_DataQualifier DetectedEntityHeader::data_qualifier() const {
  // @@protoc_insertion_point(field_get:osi3.DetectedEntityHeader.data_qualifier)
  return _internal_data_qualifier();
}
inline void DetectedEntityHeader::_internal_set_data_qualifier(::osi3::DetectedEntityHeader_DataQualifier value) {
  
  data_qualifier_ = value;
}
inline void DetectedEntityHeader::set_data_qualifier(::osi3::DetectedEntityHeader_DataQualifier value) {
  _internal_set_data_qualifier(value);
  // @@protoc_insertion_point(field_set:osi3.DetectedEntityHeader.data_qualifier)
}

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

// SensorData

// .osi3.InterfaceVersion version = 1;
inline bool SensorData::_internal_has_version() const {
  return this != internal_default_instance() && version_ != nullptr;
}
inline bool SensorData::has_version() const {
  return _internal_has_version();
}
inline const ::osi3::InterfaceVersion& SensorData::_internal_version() const {
  const ::osi3::InterfaceVersion* p = version_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::InterfaceVersion&>(
      ::osi3::_InterfaceVersion_default_instance_);
}
inline const ::osi3::InterfaceVersion& SensorData::version() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.version)
  return _internal_version();
}
inline void SensorData::unsafe_arena_set_allocated_version(
    ::osi3::InterfaceVersion* version) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(version_);
  }
  version_ = version;
  if (version) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.version)
}
inline ::osi3::InterfaceVersion* SensorData::release_version() {
  
  ::osi3::InterfaceVersion* temp = version_;
  version_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::InterfaceVersion* SensorData::unsafe_arena_release_version() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.version)
  
  ::osi3::InterfaceVersion* temp = version_;
  version_ = nullptr;
  return temp;
}
inline ::osi3::InterfaceVersion* SensorData::_internal_mutable_version() {
  
  if (version_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::InterfaceVersion>(GetArena());
    version_ = p;
  }
  return version_;
}
inline ::osi3::InterfaceVersion* SensorData::mutable_version() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.version)
  return _internal_mutable_version();
}
inline void SensorData::set_allocated_version(::osi3::InterfaceVersion* version) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(version_);
  }
  if (version) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(version)->GetArena();
    if (message_arena != submessage_arena) {
      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, version, submessage_arena);
    }
    
  } else {
    
  }
  version_ = version;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.version)
}

// .osi3.Timestamp timestamp = 2;
inline bool SensorData::_internal_has_timestamp() const {
  return this != internal_default_instance() && timestamp_ != nullptr;
}
inline bool SensorData::has_timestamp() const {
  return _internal_has_timestamp();
}
inline const ::osi3::Timestamp& SensorData::_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& SensorData::timestamp() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.timestamp)
  return _internal_timestamp();
}
inline void SensorData::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.SensorData.timestamp)
}
inline ::osi3::Timestamp* SensorData::release_timestamp() {
  
  ::osi3::Timestamp* temp = timestamp_;
  timestamp_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Timestamp* SensorData::unsafe_arena_release_timestamp() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.timestamp)
  
  ::osi3::Timestamp* temp = timestamp_;
  timestamp_ = nullptr;
  return temp;
}
inline ::osi3::Timestamp* SensorData::_internal_mutable_timestamp() {
  
  if (timestamp_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Timestamp>(GetArena());
    timestamp_ = p;
  }
  return timestamp_;
}
inline ::osi3::Timestamp* SensorData::mutable_timestamp() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.timestamp)
  return _internal_mutable_timestamp();
}
inline void SensorData::set_allocated_timestamp(::osi3::Timestamp* timestamp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_);
  }
  if (timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena();
    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.SensorData.timestamp)
}

// .osi3.BaseMoving host_vehicle_location = 3;
inline bool SensorData::_internal_has_host_vehicle_location() const {
  return this != internal_default_instance() && host_vehicle_location_ != nullptr;
}
inline bool SensorData::has_host_vehicle_location() const {
  return _internal_has_host_vehicle_location();
}
inline const ::osi3::BaseMoving& SensorData::_internal_host_vehicle_location() const {
  const ::osi3::BaseMoving* p = host_vehicle_location_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::BaseMoving&>(
      ::osi3::_BaseMoving_default_instance_);
}
inline const ::osi3::BaseMoving& SensorData::host_vehicle_location() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.host_vehicle_location)
  return _internal_host_vehicle_location();
}
inline void SensorData::unsafe_arena_set_allocated_host_vehicle_location(
    ::osi3::BaseMoving* host_vehicle_location) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location_);
  }
  host_vehicle_location_ = host_vehicle_location;
  if (host_vehicle_location) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.host_vehicle_location)
}
inline ::osi3::BaseMoving* SensorData::release_host_vehicle_location() {
  
  ::osi3::BaseMoving* temp = host_vehicle_location_;
  host_vehicle_location_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::BaseMoving* SensorData::unsafe_arena_release_host_vehicle_location() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.host_vehicle_location)
  
  ::osi3::BaseMoving* temp = host_vehicle_location_;
  host_vehicle_location_ = nullptr;
  return temp;
}
inline ::osi3::BaseMoving* SensorData::_internal_mutable_host_vehicle_location() {
  
  if (host_vehicle_location_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::BaseMoving>(GetArena());
    host_vehicle_location_ = p;
  }
  return host_vehicle_location_;
}
inline ::osi3::BaseMoving* SensorData::mutable_host_vehicle_location() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.host_vehicle_location)
  return _internal_mutable_host_vehicle_location();
}
inline void SensorData::set_allocated_host_vehicle_location(::osi3::BaseMoving* host_vehicle_location) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location_);
  }
  if (host_vehicle_location) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location)->GetArena();
    if (message_arena != submessage_arena) {
      host_vehicle_location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_vehicle_location, submessage_arena);
    }
    
  } else {
    
  }
  host_vehicle_location_ = host_vehicle_location;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.host_vehicle_location)
}

// .osi3.BaseMoving host_vehicle_location_rmse = 4;
inline bool SensorData::_internal_has_host_vehicle_location_rmse() const {
  return this != internal_default_instance() && host_vehicle_location_rmse_ != nullptr;
}
inline bool SensorData::has_host_vehicle_location_rmse() const {
  return _internal_has_host_vehicle_location_rmse();
}
inline const ::osi3::BaseMoving& SensorData::_internal_host_vehicle_location_rmse() const {
  const ::osi3::BaseMoving* p = host_vehicle_location_rmse_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::BaseMoving&>(
      ::osi3::_BaseMoving_default_instance_);
}
inline const ::osi3::BaseMoving& SensorData::host_vehicle_location_rmse() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.host_vehicle_location_rmse)
  return _internal_host_vehicle_location_rmse();
}
inline void SensorData::unsafe_arena_set_allocated_host_vehicle_location_rmse(
    ::osi3::BaseMoving* host_vehicle_location_rmse) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location_rmse_);
  }
  host_vehicle_location_rmse_ = host_vehicle_location_rmse;
  if (host_vehicle_location_rmse) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.host_vehicle_location_rmse)
}
inline ::osi3::BaseMoving* SensorData::release_host_vehicle_location_rmse() {
  
  ::osi3::BaseMoving* temp = host_vehicle_location_rmse_;
  host_vehicle_location_rmse_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::BaseMoving* SensorData::unsafe_arena_release_host_vehicle_location_rmse() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.host_vehicle_location_rmse)
  
  ::osi3::BaseMoving* temp = host_vehicle_location_rmse_;
  host_vehicle_location_rmse_ = nullptr;
  return temp;
}
inline ::osi3::BaseMoving* SensorData::_internal_mutable_host_vehicle_location_rmse() {
  
  if (host_vehicle_location_rmse_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::BaseMoving>(GetArena());
    host_vehicle_location_rmse_ = p;
  }
  return host_vehicle_location_rmse_;
}
inline ::osi3::BaseMoving* SensorData::mutable_host_vehicle_location_rmse() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.host_vehicle_location_rmse)
  return _internal_mutable_host_vehicle_location_rmse();
}
inline void SensorData::set_allocated_host_vehicle_location_rmse(::osi3::BaseMoving* host_vehicle_location_rmse) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location_rmse_);
  }
  if (host_vehicle_location_rmse) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(host_vehicle_location_rmse)->GetArena();
    if (message_arena != submessage_arena) {
      host_vehicle_location_rmse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, host_vehicle_location_rmse, submessage_arena);
    }
    
  } else {
    
  }
  host_vehicle_location_rmse_ = host_vehicle_location_rmse;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.host_vehicle_location_rmse)
}

// .osi3.Identifier sensor_id = 5;
inline bool SensorData::_internal_has_sensor_id() const {
  return this != internal_default_instance() && sensor_id_ != nullptr;
}
inline bool SensorData::has_sensor_id() const {
  return _internal_has_sensor_id();
}
inline const ::osi3::Identifier& SensorData::_internal_sensor_id() const {
  const ::osi3::Identifier* p = sensor_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Identifier&>(
      ::osi3::_Identifier_default_instance_);
}
inline const ::osi3::Identifier& SensorData::sensor_id() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.sensor_id)
  return _internal_sensor_id();
}
inline void SensorData::unsafe_arena_set_allocated_sensor_id(
    ::osi3::Identifier* sensor_id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sensor_id_);
  }
  sensor_id_ = sensor_id;
  if (sensor_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.sensor_id)
}
inline ::osi3::Identifier* SensorData::release_sensor_id() {
  
  ::osi3::Identifier* temp = sensor_id_;
  sensor_id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* SensorData::unsafe_arena_release_sensor_id() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.sensor_id)
  
  ::osi3::Identifier* temp = sensor_id_;
  sensor_id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* SensorData::_internal_mutable_sensor_id() {
  
  if (sensor_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    sensor_id_ = p;
  }
  return sensor_id_;
}
inline ::osi3::Identifier* SensorData::mutable_sensor_id() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.sensor_id)
  return _internal_mutable_sensor_id();
}
inline void SensorData::set_allocated_sensor_id(::osi3::Identifier* sensor_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(sensor_id_);
  }
  if (sensor_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sensor_id)->GetArena();
    if (message_arena != submessage_arena) {
      sensor_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sensor_id, submessage_arena);
    }
    
  } else {
    
  }
  sensor_id_ = sensor_id;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.sensor_id)
}

// .osi3.MountingPosition mounting_position = 6;
inline bool SensorData::_internal_has_mounting_position() const {
  return this != internal_default_instance() && mounting_position_ != nullptr;
}
inline bool SensorData::has_mounting_position() const {
  return _internal_has_mounting_position();
}
inline const ::osi3::MountingPosition& SensorData::_internal_mounting_position() const {
  const ::osi3::MountingPosition* p = mounting_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::MountingPosition&>(
      ::osi3::_MountingPosition_default_instance_);
}
inline const ::osi3::MountingPosition& SensorData::mounting_position() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.mounting_position)
  return _internal_mounting_position();
}
inline void SensorData::unsafe_arena_set_allocated_mounting_position(
    ::osi3::MountingPosition* mounting_position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position_);
  }
  mounting_position_ = mounting_position;
  if (mounting_position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.mounting_position)
}
inline ::osi3::MountingPosition* SensorData::release_mounting_position() {
  
  ::osi3::MountingPosition* temp = mounting_position_;
  mounting_position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::MountingPosition* SensorData::unsafe_arena_release_mounting_position() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.mounting_position)
  
  ::osi3::MountingPosition* temp = mounting_position_;
  mounting_position_ = nullptr;
  return temp;
}
inline ::osi3::MountingPosition* SensorData::_internal_mutable_mounting_position() {
  
  if (mounting_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::MountingPosition>(GetArena());
    mounting_position_ = p;
  }
  return mounting_position_;
}
inline ::osi3::MountingPosition* SensorData::mutable_mounting_position() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.mounting_position)
  return _internal_mutable_mounting_position();
}
inline void SensorData::set_allocated_mounting_position(::osi3::MountingPosition* mounting_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position_);
  }
  if (mounting_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position)->GetArena();
    if (message_arena != submessage_arena) {
      mounting_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mounting_position, submessage_arena);
    }
    
  } else {
    
  }
  mounting_position_ = mounting_position;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.mounting_position)
}

// .osi3.MountingPosition mounting_position_rmse = 7;
inline bool SensorData::_internal_has_mounting_position_rmse() const {
  return this != internal_default_instance() && mounting_position_rmse_ != nullptr;
}
inline bool SensorData::has_mounting_position_rmse() const {
  return _internal_has_mounting_position_rmse();
}
inline const ::osi3::MountingPosition& SensorData::_internal_mounting_position_rmse() const {
  const ::osi3::MountingPosition* p = mounting_position_rmse_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::MountingPosition&>(
      ::osi3::_MountingPosition_default_instance_);
}
inline const ::osi3::MountingPosition& SensorData::mounting_position_rmse() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.mounting_position_rmse)
  return _internal_mounting_position_rmse();
}
inline void SensorData::unsafe_arena_set_allocated_mounting_position_rmse(
    ::osi3::MountingPosition* mounting_position_rmse) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position_rmse_);
  }
  mounting_position_rmse_ = mounting_position_rmse;
  if (mounting_position_rmse) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.mounting_position_rmse)
}
inline ::osi3::MountingPosition* SensorData::release_mounting_position_rmse() {
  
  ::osi3::MountingPosition* temp = mounting_position_rmse_;
  mounting_position_rmse_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::MountingPosition* SensorData::unsafe_arena_release_mounting_position_rmse() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.mounting_position_rmse)
  
  ::osi3::MountingPosition* temp = mounting_position_rmse_;
  mounting_position_rmse_ = nullptr;
  return temp;
}
inline ::osi3::MountingPosition* SensorData::_internal_mutable_mounting_position_rmse() {
  
  if (mounting_position_rmse_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::MountingPosition>(GetArena());
    mounting_position_rmse_ = p;
  }
  return mounting_position_rmse_;
}
inline ::osi3::MountingPosition* SensorData::mutable_mounting_position_rmse() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.mounting_position_rmse)
  return _internal_mutable_mounting_position_rmse();
}
inline void SensorData::set_allocated_mounting_position_rmse(::osi3::MountingPosition* mounting_position_rmse) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position_rmse_);
  }
  if (mounting_position_rmse) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mounting_position_rmse)->GetArena();
    if (message_arena != submessage_arena) {
      mounting_position_rmse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mounting_position_rmse, submessage_arena);
    }
    
  } else {
    
  }
  mounting_position_rmse_ = mounting_position_rmse;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.mounting_position_rmse)
}

// repeated .osi3.SensorView sensor_view = 8;
inline int SensorData::_internal_sensor_view_size() const {
  return sensor_view_.size();
}
inline int SensorData::sensor_view_size() const {
  return _internal_sensor_view_size();
}
inline ::osi3::SensorView* SensorData::mutable_sensor_view(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.sensor_view)
  return sensor_view_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::SensorView >*
SensorData::mutable_sensor_view() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.sensor_view)
  return &sensor_view_;
}
inline const ::osi3::SensorView& SensorData::_internal_sensor_view(int index) const {
  return sensor_view_.Get(index);
}
inline const ::osi3::SensorView& SensorData::sensor_view(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.sensor_view)
  return _internal_sensor_view(index);
}
inline ::osi3::SensorView* SensorData::_internal_add_sensor_view() {
  return sensor_view_.Add();
}
inline ::osi3::SensorView* SensorData::add_sensor_view() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.sensor_view)
  return _internal_add_sensor_view();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::SensorView >&
SensorData::sensor_view() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.sensor_view)
  return sensor_view_;
}

// .osi3.Timestamp last_measurement_time = 9;
inline bool SensorData::_internal_has_last_measurement_time() const {
  return this != internal_default_instance() && last_measurement_time_ != nullptr;
}
inline bool SensorData::has_last_measurement_time() const {
  return _internal_has_last_measurement_time();
}
inline const ::osi3::Timestamp& SensorData::_internal_last_measurement_time() const {
  const ::osi3::Timestamp* p = last_measurement_time_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Timestamp&>(
      ::osi3::_Timestamp_default_instance_);
}
inline const ::osi3::Timestamp& SensorData::last_measurement_time() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.last_measurement_time)
  return _internal_last_measurement_time();
}
inline void SensorData::unsafe_arena_set_allocated_last_measurement_time(
    ::osi3::Timestamp* last_measurement_time) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(last_measurement_time_);
  }
  last_measurement_time_ = last_measurement_time;
  if (last_measurement_time) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.last_measurement_time)
}
inline ::osi3::Timestamp* SensorData::release_last_measurement_time() {
  
  ::osi3::Timestamp* temp = last_measurement_time_;
  last_measurement_time_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Timestamp* SensorData::unsafe_arena_release_last_measurement_time() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.last_measurement_time)
  
  ::osi3::Timestamp* temp = last_measurement_time_;
  last_measurement_time_ = nullptr;
  return temp;
}
inline ::osi3::Timestamp* SensorData::_internal_mutable_last_measurement_time() {
  
  if (last_measurement_time_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Timestamp>(GetArena());
    last_measurement_time_ = p;
  }
  return last_measurement_time_;
}
inline ::osi3::Timestamp* SensorData::mutable_last_measurement_time() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.last_measurement_time)
  return _internal_mutable_last_measurement_time();
}
inline void SensorData::set_allocated_last_measurement_time(::osi3::Timestamp* last_measurement_time) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(last_measurement_time_);
  }
  if (last_measurement_time) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(last_measurement_time)->GetArena();
    if (message_arena != submessage_arena) {
      last_measurement_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, last_measurement_time, submessage_arena);
    }
    
  } else {
    
  }
  last_measurement_time_ = last_measurement_time;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.last_measurement_time)
}

// .osi3.DetectedEntityHeader stationary_object_header = 10;
inline bool SensorData::_internal_has_stationary_object_header() const {
  return this != internal_default_instance() && stationary_object_header_ != nullptr;
}
inline bool SensorData::has_stationary_object_header() const {
  return _internal_has_stationary_object_header();
}
inline void SensorData::clear_stationary_object_header() {
  if (GetArena() == nullptr && stationary_object_header_ != nullptr) {
    delete stationary_object_header_;
  }
  stationary_object_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_stationary_object_header() const {
  const ::osi3::DetectedEntityHeader* p = stationary_object_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::stationary_object_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.stationary_object_header)
  return _internal_stationary_object_header();
}
inline void SensorData::unsafe_arena_set_allocated_stationary_object_header(
    ::osi3::DetectedEntityHeader* stationary_object_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stationary_object_header_);
  }
  stationary_object_header_ = stationary_object_header;
  if (stationary_object_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.stationary_object_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_stationary_object_header() {
  
  ::osi3::DetectedEntityHeader* temp = stationary_object_header_;
  stationary_object_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_stationary_object_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.stationary_object_header)
  
  ::osi3::DetectedEntityHeader* temp = stationary_object_header_;
  stationary_object_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_stationary_object_header() {
  
  if (stationary_object_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    stationary_object_header_ = p;
  }
  return stationary_object_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_stationary_object_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.stationary_object_header)
  return _internal_mutable_stationary_object_header();
}
inline void SensorData::set_allocated_stationary_object_header(::osi3::DetectedEntityHeader* stationary_object_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete stationary_object_header_;
  }
  if (stationary_object_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stationary_object_header);
    if (message_arena != submessage_arena) {
      stationary_object_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stationary_object_header, submessage_arena);
    }
    
  } else {
    
  }
  stationary_object_header_ = stationary_object_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.stationary_object_header)
}

// repeated .osi3.DetectedStationaryObject stationary_object = 11;
inline int SensorData::_internal_stationary_object_size() const {
  return stationary_object_.size();
}
inline int SensorData::stationary_object_size() const {
  return _internal_stationary_object_size();
}
inline ::osi3::DetectedStationaryObject* SensorData::mutable_stationary_object(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.stationary_object)
  return stationary_object_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedStationaryObject >*
SensorData::mutable_stationary_object() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.stationary_object)
  return &stationary_object_;
}
inline const ::osi3::DetectedStationaryObject& SensorData::_internal_stationary_object(int index) const {
  return stationary_object_.Get(index);
}
inline const ::osi3::DetectedStationaryObject& SensorData::stationary_object(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.stationary_object)
  return _internal_stationary_object(index);
}
inline ::osi3::DetectedStationaryObject* SensorData::_internal_add_stationary_object() {
  return stationary_object_.Add();
}
inline ::osi3::DetectedStationaryObject* SensorData::add_stationary_object() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.stationary_object)
  return _internal_add_stationary_object();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedStationaryObject >&
SensorData::stationary_object() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.stationary_object)
  return stationary_object_;
}

// .osi3.DetectedEntityHeader moving_object_header = 12;
inline bool SensorData::_internal_has_moving_object_header() const {
  return this != internal_default_instance() && moving_object_header_ != nullptr;
}
inline bool SensorData::has_moving_object_header() const {
  return _internal_has_moving_object_header();
}
inline void SensorData::clear_moving_object_header() {
  if (GetArena() == nullptr && moving_object_header_ != nullptr) {
    delete moving_object_header_;
  }
  moving_object_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_moving_object_header() const {
  const ::osi3::DetectedEntityHeader* p = moving_object_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::moving_object_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.moving_object_header)
  return _internal_moving_object_header();
}
inline void SensorData::unsafe_arena_set_allocated_moving_object_header(
    ::osi3::DetectedEntityHeader* moving_object_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(moving_object_header_);
  }
  moving_object_header_ = moving_object_header;
  if (moving_object_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.moving_object_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_moving_object_header() {
  
  ::osi3::DetectedEntityHeader* temp = moving_object_header_;
  moving_object_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_moving_object_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.moving_object_header)
  
  ::osi3::DetectedEntityHeader* temp = moving_object_header_;
  moving_object_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_moving_object_header() {
  
  if (moving_object_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    moving_object_header_ = p;
  }
  return moving_object_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_moving_object_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.moving_object_header)
  return _internal_mutable_moving_object_header();
}
inline void SensorData::set_allocated_moving_object_header(::osi3::DetectedEntityHeader* moving_object_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete moving_object_header_;
  }
  if (moving_object_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(moving_object_header);
    if (message_arena != submessage_arena) {
      moving_object_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, moving_object_header, submessage_arena);
    }
    
  } else {
    
  }
  moving_object_header_ = moving_object_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.moving_object_header)
}

// repeated .osi3.DetectedMovingObject moving_object = 13;
inline int SensorData::_internal_moving_object_size() const {
  return moving_object_.size();
}
inline int SensorData::moving_object_size() const {
  return _internal_moving_object_size();
}
inline ::osi3::DetectedMovingObject* SensorData::mutable_moving_object(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.moving_object)
  return moving_object_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedMovingObject >*
SensorData::mutable_moving_object() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.moving_object)
  return &moving_object_;
}
inline const ::osi3::DetectedMovingObject& SensorData::_internal_moving_object(int index) const {
  return moving_object_.Get(index);
}
inline const ::osi3::DetectedMovingObject& SensorData::moving_object(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.moving_object)
  return _internal_moving_object(index);
}
inline ::osi3::DetectedMovingObject* SensorData::_internal_add_moving_object() {
  return moving_object_.Add();
}
inline ::osi3::DetectedMovingObject* SensorData::add_moving_object() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.moving_object)
  return _internal_add_moving_object();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedMovingObject >&
SensorData::moving_object() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.moving_object)
  return moving_object_;
}

// .osi3.DetectedEntityHeader traffic_sign_header = 14;
inline bool SensorData::_internal_has_traffic_sign_header() const {
  return this != internal_default_instance() && traffic_sign_header_ != nullptr;
}
inline bool SensorData::has_traffic_sign_header() const {
  return _internal_has_traffic_sign_header();
}
inline void SensorData::clear_traffic_sign_header() {
  if (GetArena() == nullptr && traffic_sign_header_ != nullptr) {
    delete traffic_sign_header_;
  }
  traffic_sign_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_traffic_sign_header() const {
  const ::osi3::DetectedEntityHeader* p = traffic_sign_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::traffic_sign_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.traffic_sign_header)
  return _internal_traffic_sign_header();
}
inline void SensorData::unsafe_arena_set_allocated_traffic_sign_header(
    ::osi3::DetectedEntityHeader* traffic_sign_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(traffic_sign_header_);
  }
  traffic_sign_header_ = traffic_sign_header;
  if (traffic_sign_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.traffic_sign_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_traffic_sign_header() {
  
  ::osi3::DetectedEntityHeader* temp = traffic_sign_header_;
  traffic_sign_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_traffic_sign_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.traffic_sign_header)
  
  ::osi3::DetectedEntityHeader* temp = traffic_sign_header_;
  traffic_sign_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_traffic_sign_header() {
  
  if (traffic_sign_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    traffic_sign_header_ = p;
  }
  return traffic_sign_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_traffic_sign_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.traffic_sign_header)
  return _internal_mutable_traffic_sign_header();
}
inline void SensorData::set_allocated_traffic_sign_header(::osi3::DetectedEntityHeader* traffic_sign_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete traffic_sign_header_;
  }
  if (traffic_sign_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(traffic_sign_header);
    if (message_arena != submessage_arena) {
      traffic_sign_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, traffic_sign_header, submessage_arena);
    }
    
  } else {
    
  }
  traffic_sign_header_ = traffic_sign_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.traffic_sign_header)
}

// repeated .osi3.DetectedTrafficSign traffic_sign = 15;
inline int SensorData::_internal_traffic_sign_size() const {
  return traffic_sign_.size();
}
inline int SensorData::traffic_sign_size() const {
  return _internal_traffic_sign_size();
}
inline ::osi3::DetectedTrafficSign* SensorData::mutable_traffic_sign(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.traffic_sign)
  return traffic_sign_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficSign >*
SensorData::mutable_traffic_sign() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.traffic_sign)
  return &traffic_sign_;
}
inline const ::osi3::DetectedTrafficSign& SensorData::_internal_traffic_sign(int index) const {
  return traffic_sign_.Get(index);
}
inline const ::osi3::DetectedTrafficSign& SensorData::traffic_sign(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.traffic_sign)
  return _internal_traffic_sign(index);
}
inline ::osi3::DetectedTrafficSign* SensorData::_internal_add_traffic_sign() {
  return traffic_sign_.Add();
}
inline ::osi3::DetectedTrafficSign* SensorData::add_traffic_sign() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.traffic_sign)
  return _internal_add_traffic_sign();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficSign >&
SensorData::traffic_sign() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.traffic_sign)
  return traffic_sign_;
}

// .osi3.DetectedEntityHeader traffic_light_header = 16;
inline bool SensorData::_internal_has_traffic_light_header() const {
  return this != internal_default_instance() && traffic_light_header_ != nullptr;
}
inline bool SensorData::has_traffic_light_header() const {
  return _internal_has_traffic_light_header();
}
inline void SensorData::clear_traffic_light_header() {
  if (GetArena() == nullptr && traffic_light_header_ != nullptr) {
    delete traffic_light_header_;
  }
  traffic_light_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_traffic_light_header() const {
  const ::osi3::DetectedEntityHeader* p = traffic_light_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::traffic_light_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.traffic_light_header)
  return _internal_traffic_light_header();
}
inline void SensorData::unsafe_arena_set_allocated_traffic_light_header(
    ::osi3::DetectedEntityHeader* traffic_light_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(traffic_light_header_);
  }
  traffic_light_header_ = traffic_light_header;
  if (traffic_light_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.traffic_light_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_traffic_light_header() {
  
  ::osi3::DetectedEntityHeader* temp = traffic_light_header_;
  traffic_light_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_traffic_light_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.traffic_light_header)
  
  ::osi3::DetectedEntityHeader* temp = traffic_light_header_;
  traffic_light_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_traffic_light_header() {
  
  if (traffic_light_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    traffic_light_header_ = p;
  }
  return traffic_light_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_traffic_light_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.traffic_light_header)
  return _internal_mutable_traffic_light_header();
}
inline void SensorData::set_allocated_traffic_light_header(::osi3::DetectedEntityHeader* traffic_light_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete traffic_light_header_;
  }
  if (traffic_light_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(traffic_light_header);
    if (message_arena != submessage_arena) {
      traffic_light_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, traffic_light_header, submessage_arena);
    }
    
  } else {
    
  }
  traffic_light_header_ = traffic_light_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.traffic_light_header)
}

// repeated .osi3.DetectedTrafficLight traffic_light = 17;
inline int SensorData::_internal_traffic_light_size() const {
  return traffic_light_.size();
}
inline int SensorData::traffic_light_size() const {
  return _internal_traffic_light_size();
}
inline ::osi3::DetectedTrafficLight* SensorData::mutable_traffic_light(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.traffic_light)
  return traffic_light_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficLight >*
SensorData::mutable_traffic_light() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.traffic_light)
  return &traffic_light_;
}
inline const ::osi3::DetectedTrafficLight& SensorData::_internal_traffic_light(int index) const {
  return traffic_light_.Get(index);
}
inline const ::osi3::DetectedTrafficLight& SensorData::traffic_light(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.traffic_light)
  return _internal_traffic_light(index);
}
inline ::osi3::DetectedTrafficLight* SensorData::_internal_add_traffic_light() {
  return traffic_light_.Add();
}
inline ::osi3::DetectedTrafficLight* SensorData::add_traffic_light() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.traffic_light)
  return _internal_add_traffic_light();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedTrafficLight >&
SensorData::traffic_light() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.traffic_light)
  return traffic_light_;
}

// .osi3.DetectedEntityHeader road_marking_header = 18;
inline bool SensorData::_internal_has_road_marking_header() const {
  return this != internal_default_instance() && road_marking_header_ != nullptr;
}
inline bool SensorData::has_road_marking_header() const {
  return _internal_has_road_marking_header();
}
inline void SensorData::clear_road_marking_header() {
  if (GetArena() == nullptr && road_marking_header_ != nullptr) {
    delete road_marking_header_;
  }
  road_marking_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_road_marking_header() const {
  const ::osi3::DetectedEntityHeader* p = road_marking_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::road_marking_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.road_marking_header)
  return _internal_road_marking_header();
}
inline void SensorData::unsafe_arena_set_allocated_road_marking_header(
    ::osi3::DetectedEntityHeader* road_marking_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(road_marking_header_);
  }
  road_marking_header_ = road_marking_header;
  if (road_marking_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.road_marking_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_road_marking_header() {
  
  ::osi3::DetectedEntityHeader* temp = road_marking_header_;
  road_marking_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_road_marking_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.road_marking_header)
  
  ::osi3::DetectedEntityHeader* temp = road_marking_header_;
  road_marking_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_road_marking_header() {
  
  if (road_marking_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    road_marking_header_ = p;
  }
  return road_marking_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_road_marking_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.road_marking_header)
  return _internal_mutable_road_marking_header();
}
inline void SensorData::set_allocated_road_marking_header(::osi3::DetectedEntityHeader* road_marking_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete road_marking_header_;
  }
  if (road_marking_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(road_marking_header);
    if (message_arena != submessage_arena) {
      road_marking_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, road_marking_header, submessage_arena);
    }
    
  } else {
    
  }
  road_marking_header_ = road_marking_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.road_marking_header)
}

// repeated .osi3.DetectedRoadMarking road_marking = 19;
inline int SensorData::_internal_road_marking_size() const {
  return road_marking_.size();
}
inline int SensorData::road_marking_size() const {
  return _internal_road_marking_size();
}
inline ::osi3::DetectedRoadMarking* SensorData::mutable_road_marking(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.road_marking)
  return road_marking_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedRoadMarking >*
SensorData::mutable_road_marking() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.road_marking)
  return &road_marking_;
}
inline const ::osi3::DetectedRoadMarking& SensorData::_internal_road_marking(int index) const {
  return road_marking_.Get(index);
}
inline const ::osi3::DetectedRoadMarking& SensorData::road_marking(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.road_marking)
  return _internal_road_marking(index);
}
inline ::osi3::DetectedRoadMarking* SensorData::_internal_add_road_marking() {
  return road_marking_.Add();
}
inline ::osi3::DetectedRoadMarking* SensorData::add_road_marking() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.road_marking)
  return _internal_add_road_marking();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedRoadMarking >&
SensorData::road_marking() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.road_marking)
  return road_marking_;
}

// .osi3.DetectedEntityHeader lane_boundary_header = 20;
inline bool SensorData::_internal_has_lane_boundary_header() const {
  return this != internal_default_instance() && lane_boundary_header_ != nullptr;
}
inline bool SensorData::has_lane_boundary_header() const {
  return _internal_has_lane_boundary_header();
}
inline void SensorData::clear_lane_boundary_header() {
  if (GetArena() == nullptr && lane_boundary_header_ != nullptr) {
    delete lane_boundary_header_;
  }
  lane_boundary_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_lane_boundary_header() const {
  const ::osi3::DetectedEntityHeader* p = lane_boundary_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::lane_boundary_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.lane_boundary_header)
  return _internal_lane_boundary_header();
}
inline void SensorData::unsafe_arena_set_allocated_lane_boundary_header(
    ::osi3::DetectedEntityHeader* lane_boundary_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lane_boundary_header_);
  }
  lane_boundary_header_ = lane_boundary_header;
  if (lane_boundary_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.lane_boundary_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_lane_boundary_header() {
  
  ::osi3::DetectedEntityHeader* temp = lane_boundary_header_;
  lane_boundary_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_lane_boundary_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.lane_boundary_header)
  
  ::osi3::DetectedEntityHeader* temp = lane_boundary_header_;
  lane_boundary_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_lane_boundary_header() {
  
  if (lane_boundary_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    lane_boundary_header_ = p;
  }
  return lane_boundary_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_lane_boundary_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.lane_boundary_header)
  return _internal_mutable_lane_boundary_header();
}
inline void SensorData::set_allocated_lane_boundary_header(::osi3::DetectedEntityHeader* lane_boundary_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete lane_boundary_header_;
  }
  if (lane_boundary_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lane_boundary_header);
    if (message_arena != submessage_arena) {
      lane_boundary_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lane_boundary_header, submessage_arena);
    }
    
  } else {
    
  }
  lane_boundary_header_ = lane_boundary_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.lane_boundary_header)
}

// repeated .osi3.DetectedLaneBoundary lane_boundary = 21;
inline int SensorData::_internal_lane_boundary_size() const {
  return lane_boundary_.size();
}
inline int SensorData::lane_boundary_size() const {
  return _internal_lane_boundary_size();
}
inline ::osi3::DetectedLaneBoundary* SensorData::mutable_lane_boundary(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.lane_boundary)
  return lane_boundary_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLaneBoundary >*
SensorData::mutable_lane_boundary() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.lane_boundary)
  return &lane_boundary_;
}
inline const ::osi3::DetectedLaneBoundary& SensorData::_internal_lane_boundary(int index) const {
  return lane_boundary_.Get(index);
}
inline const ::osi3::DetectedLaneBoundary& SensorData::lane_boundary(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.lane_boundary)
  return _internal_lane_boundary(index);
}
inline ::osi3::DetectedLaneBoundary* SensorData::_internal_add_lane_boundary() {
  return lane_boundary_.Add();
}
inline ::osi3::DetectedLaneBoundary* SensorData::add_lane_boundary() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.lane_boundary)
  return _internal_add_lane_boundary();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLaneBoundary >&
SensorData::lane_boundary() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.lane_boundary)
  return lane_boundary_;
}

// .osi3.DetectedEntityHeader lane_header = 22;
inline bool SensorData::_internal_has_lane_header() const {
  return this != internal_default_instance() && lane_header_ != nullptr;
}
inline bool SensorData::has_lane_header() const {
  return _internal_has_lane_header();
}
inline void SensorData::clear_lane_header() {
  if (GetArena() == nullptr && lane_header_ != nullptr) {
    delete lane_header_;
  }
  lane_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_lane_header() const {
  const ::osi3::DetectedEntityHeader* p = lane_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::lane_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.lane_header)
  return _internal_lane_header();
}
inline void SensorData::unsafe_arena_set_allocated_lane_header(
    ::osi3::DetectedEntityHeader* lane_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lane_header_);
  }
  lane_header_ = lane_header;
  if (lane_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.lane_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_lane_header() {
  
  ::osi3::DetectedEntityHeader* temp = lane_header_;
  lane_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_lane_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.lane_header)
  
  ::osi3::DetectedEntityHeader* temp = lane_header_;
  lane_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_lane_header() {
  
  if (lane_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    lane_header_ = p;
  }
  return lane_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_lane_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.lane_header)
  return _internal_mutable_lane_header();
}
inline void SensorData::set_allocated_lane_header(::osi3::DetectedEntityHeader* lane_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete lane_header_;
  }
  if (lane_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lane_header);
    if (message_arena != submessage_arena) {
      lane_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lane_header, submessage_arena);
    }
    
  } else {
    
  }
  lane_header_ = lane_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.lane_header)
}

// repeated .osi3.DetectedLane lane = 23;
inline int SensorData::_internal_lane_size() const {
  return lane_.size();
}
inline int SensorData::lane_size() const {
  return _internal_lane_size();
}
inline ::osi3::DetectedLane* SensorData::mutable_lane(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.lane)
  return lane_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLane >*
SensorData::mutable_lane() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.lane)
  return &lane_;
}
inline const ::osi3::DetectedLane& SensorData::_internal_lane(int index) const {
  return lane_.Get(index);
}
inline const ::osi3::DetectedLane& SensorData::lane(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.lane)
  return _internal_lane(index);
}
inline ::osi3::DetectedLane* SensorData::_internal_add_lane() {
  return lane_.Add();
}
inline ::osi3::DetectedLane* SensorData::add_lane() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.lane)
  return _internal_add_lane();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedLane >&
SensorData::lane() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.lane)
  return lane_;
}

// .osi3.DetectedEntityHeader occupant_header = 24;
inline bool SensorData::_internal_has_occupant_header() const {
  return this != internal_default_instance() && occupant_header_ != nullptr;
}
inline bool SensorData::has_occupant_header() const {
  return _internal_has_occupant_header();
}
inline void SensorData::clear_occupant_header() {
  if (GetArena() == nullptr && occupant_header_ != nullptr) {
    delete occupant_header_;
  }
  occupant_header_ = nullptr;
}
inline const ::osi3::DetectedEntityHeader& SensorData::_internal_occupant_header() const {
  const ::osi3::DetectedEntityHeader* p = occupant_header_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::DetectedEntityHeader&>(
      ::osi3::_DetectedEntityHeader_default_instance_);
}
inline const ::osi3::DetectedEntityHeader& SensorData::occupant_header() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.occupant_header)
  return _internal_occupant_header();
}
inline void SensorData::unsafe_arena_set_allocated_occupant_header(
    ::osi3::DetectedEntityHeader* occupant_header) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(occupant_header_);
  }
  occupant_header_ = occupant_header;
  if (occupant_header) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.occupant_header)
}
inline ::osi3::DetectedEntityHeader* SensorData::release_occupant_header() {
  
  ::osi3::DetectedEntityHeader* temp = occupant_header_;
  occupant_header_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::unsafe_arena_release_occupant_header() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.occupant_header)
  
  ::osi3::DetectedEntityHeader* temp = occupant_header_;
  occupant_header_ = nullptr;
  return temp;
}
inline ::osi3::DetectedEntityHeader* SensorData::_internal_mutable_occupant_header() {
  
  if (occupant_header_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::DetectedEntityHeader>(GetArena());
    occupant_header_ = p;
  }
  return occupant_header_;
}
inline ::osi3::DetectedEntityHeader* SensorData::mutable_occupant_header() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.occupant_header)
  return _internal_mutable_occupant_header();
}
inline void SensorData::set_allocated_occupant_header(::osi3::DetectedEntityHeader* occupant_header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete occupant_header_;
  }
  if (occupant_header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(occupant_header);
    if (message_arena != submessage_arena) {
      occupant_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, occupant_header, submessage_arena);
    }
    
  } else {
    
  }
  occupant_header_ = occupant_header;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.occupant_header)
}

// repeated .osi3.DetectedOccupant occupant = 25;
inline int SensorData::_internal_occupant_size() const {
  return occupant_.size();
}
inline int SensorData::occupant_size() const {
  return _internal_occupant_size();
}
inline ::osi3::DetectedOccupant* SensorData::mutable_occupant(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.occupant)
  return occupant_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedOccupant >*
SensorData::mutable_occupant() {
  // @@protoc_insertion_point(field_mutable_list:osi3.SensorData.occupant)
  return &occupant_;
}
inline const ::osi3::DetectedOccupant& SensorData::_internal_occupant(int index) const {
  return occupant_.Get(index);
}
inline const ::osi3::DetectedOccupant& SensorData::occupant(int index) const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.occupant)
  return _internal_occupant(index);
}
inline ::osi3::DetectedOccupant* SensorData::_internal_add_occupant() {
  return occupant_.Add();
}
inline ::osi3::DetectedOccupant* SensorData::add_occupant() {
  // @@protoc_insertion_point(field_add:osi3.SensorData.occupant)
  return _internal_add_occupant();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::DetectedOccupant >&
SensorData::occupant() const {
  // @@protoc_insertion_point(field_list:osi3.SensorData.occupant)
  return occupant_;
}

// .osi3.FeatureData feature_data = 26;
inline bool SensorData::_internal_has_feature_data() const {
  return this != internal_default_instance() && feature_data_ != nullptr;
}
inline bool SensorData::has_feature_data() const {
  return _internal_has_feature_data();
}
inline const ::osi3::FeatureData& SensorData::_internal_feature_data() const {
  const ::osi3::FeatureData* p = feature_data_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::FeatureData&>(
      ::osi3::_FeatureData_default_instance_);
}
inline const ::osi3::FeatureData& SensorData::feature_data() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.feature_data)
  return _internal_feature_data();
}
inline void SensorData::unsafe_arena_set_allocated_feature_data(
    ::osi3::FeatureData* feature_data) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(feature_data_);
  }
  feature_data_ = feature_data;
  if (feature_data) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.feature_data)
}
inline ::osi3::FeatureData* SensorData::release_feature_data() {
  
  ::osi3::FeatureData* temp = feature_data_;
  feature_data_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::FeatureData* SensorData::unsafe_arena_release_feature_data() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.feature_data)
  
  ::osi3::FeatureData* temp = feature_data_;
  feature_data_ = nullptr;
  return temp;
}
inline ::osi3::FeatureData* SensorData::_internal_mutable_feature_data() {
  
  if (feature_data_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::FeatureData>(GetArena());
    feature_data_ = p;
  }
  return feature_data_;
}
inline ::osi3::FeatureData* SensorData::mutable_feature_data() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.feature_data)
  return _internal_mutable_feature_data();
}
inline void SensorData::set_allocated_feature_data(::osi3::FeatureData* feature_data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(feature_data_);
  }
  if (feature_data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(feature_data)->GetArena();
    if (message_arena != submessage_arena) {
      feature_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, feature_data, submessage_arena);
    }
    
  } else {
    
  }
  feature_data_ = feature_data;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.feature_data)
}

// .osi3.LogicalDetectionData logical_detection_data = 27;
inline bool SensorData::_internal_has_logical_detection_data() const {
  return this != internal_default_instance() && logical_detection_data_ != nullptr;
}
inline bool SensorData::has_logical_detection_data() const {
  return _internal_has_logical_detection_data();
}
inline const ::osi3::LogicalDetectionData& SensorData::_internal_logical_detection_data() const {
  const ::osi3::LogicalDetectionData* p = logical_detection_data_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::LogicalDetectionData&>(
      ::osi3::_LogicalDetectionData_default_instance_);
}
inline const ::osi3::LogicalDetectionData& SensorData::logical_detection_data() const {
  // @@protoc_insertion_point(field_get:osi3.SensorData.logical_detection_data)
  return _internal_logical_detection_data();
}
inline void SensorData::unsafe_arena_set_allocated_logical_detection_data(
    ::osi3::LogicalDetectionData* logical_detection_data) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(logical_detection_data_);
  }
  logical_detection_data_ = logical_detection_data;
  if (logical_detection_data) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.SensorData.logical_detection_data)
}
inline ::osi3::LogicalDetectionData* SensorData::release_logical_detection_data() {
  
  ::osi3::LogicalDetectionData* temp = logical_detection_data_;
  logical_detection_data_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::LogicalDetectionData* SensorData::unsafe_arena_release_logical_detection_data() {
  // @@protoc_insertion_point(field_release:osi3.SensorData.logical_detection_data)
  
  ::osi3::LogicalDetectionData* temp = logical_detection_data_;
  logical_detection_data_ = nullptr;
  return temp;
}
inline ::osi3::LogicalDetectionData* SensorData::_internal_mutable_logical_detection_data() {
  
  if (logical_detection_data_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::LogicalDetectionData>(GetArena());
    logical_detection_data_ = p;
  }
  return logical_detection_data_;
}
inline ::osi3::LogicalDetectionData* SensorData::mutable_logical_detection_data() {
  // @@protoc_insertion_point(field_mutable:osi3.SensorData.logical_detection_data)
  return _internal_mutable_logical_detection_data();
}
inline void SensorData::set_allocated_logical_detection_data(::osi3::LogicalDetectionData* logical_detection_data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(logical_detection_data_);
  }
  if (logical_detection_data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(logical_detection_data)->GetArena();
    if (message_arena != submessage_arena) {
      logical_detection_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, logical_detection_data, submessage_arena);
    }
    
  } else {
    
  }
  logical_detection_data_ = logical_detection_data;
  // @@protoc_insertion_point(field_set_allocated:osi3.SensorData.logical_detection_data)
}

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace osi3

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::osi3::DetectedEntityHeader_DataQualifier> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::DetectedEntityHeader_DataQualifier>() {
  return ::osi3::DetectedEntityHeader_DataQualifier_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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