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

#ifndef GOOGLE_PROTOBUF_INCLUDED_osi_5flane_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_osi_5flane_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_common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_osi_5flane_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_osi_5flane_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[7]
    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_5flane_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_osi_5flane_2eproto_metadata_getter(int index);
namespace osi3 {
class Lane;
struct LaneDefaultTypeInternal;
extern LaneDefaultTypeInternal _Lane_default_instance_;
class LaneBoundary;
struct LaneBoundaryDefaultTypeInternal;
extern LaneBoundaryDefaultTypeInternal _LaneBoundary_default_instance_;
class LaneBoundary_BoundaryPoint;
struct LaneBoundary_BoundaryPointDefaultTypeInternal;
extern LaneBoundary_BoundaryPointDefaultTypeInternal _LaneBoundary_BoundaryPoint_default_instance_;
class LaneBoundary_Classification;
struct LaneBoundary_ClassificationDefaultTypeInternal;
extern LaneBoundary_ClassificationDefaultTypeInternal _LaneBoundary_Classification_default_instance_;
class Lane_Classification;
struct Lane_ClassificationDefaultTypeInternal;
extern Lane_ClassificationDefaultTypeInternal _Lane_Classification_default_instance_;
class Lane_Classification_LanePairing;
struct Lane_Classification_LanePairingDefaultTypeInternal;
extern Lane_Classification_LanePairingDefaultTypeInternal _Lane_Classification_LanePairing_default_instance_;
class Lane_Classification_RoadCondition;
struct Lane_Classification_RoadConditionDefaultTypeInternal;
extern Lane_Classification_RoadConditionDefaultTypeInternal _Lane_Classification_RoadCondition_default_instance_;
}  // namespace osi3
PROTOBUF_NAMESPACE_OPEN
template<> ::osi3::Lane* Arena::CreateMaybeMessage<::osi3::Lane>(Arena*);
template<> ::osi3::LaneBoundary* Arena::CreateMaybeMessage<::osi3::LaneBoundary>(Arena*);
template<> ::osi3::LaneBoundary_BoundaryPoint* Arena::CreateMaybeMessage<::osi3::LaneBoundary_BoundaryPoint>(Arena*);
template<> ::osi3::LaneBoundary_Classification* Arena::CreateMaybeMessage<::osi3::LaneBoundary_Classification>(Arena*);
template<> ::osi3::Lane_Classification* Arena::CreateMaybeMessage<::osi3::Lane_Classification>(Arena*);
template<> ::osi3::Lane_Classification_LanePairing* Arena::CreateMaybeMessage<::osi3::Lane_Classification_LanePairing>(Arena*);
template<> ::osi3::Lane_Classification_RoadCondition* Arena::CreateMaybeMessage<::osi3::Lane_Classification_RoadCondition>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace osi3 {

enum Lane_Classification_Type : int {
  Lane_Classification_Type_TYPE_UNKNOWN = 0,
  Lane_Classification_Type_TYPE_OTHER = 1,
  Lane_Classification_Type_TYPE_DRIVING = 2,
  Lane_Classification_Type_TYPE_NONDRIVING = 3,
  Lane_Classification_Type_TYPE_INTERSECTION = 4,
  Lane_Classification_Type_Lane_Classification_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Lane_Classification_Type_Lane_Classification_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Lane_Classification_Type_IsValid(int value);
constexpr Lane_Classification_Type Lane_Classification_Type_Type_MIN = Lane_Classification_Type_TYPE_UNKNOWN;
constexpr Lane_Classification_Type Lane_Classification_Type_Type_MAX = Lane_Classification_Type_TYPE_INTERSECTION;
constexpr int Lane_Classification_Type_Type_ARRAYSIZE = Lane_Classification_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Lane_Classification_Type_descriptor();
template<typename T>
inline const std::string& Lane_Classification_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Lane_Classification_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Lane_Classification_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Lane_Classification_Type_descriptor(), enum_t_value);
}
inline bool Lane_Classification_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Lane_Classification_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Lane_Classification_Type>(
    Lane_Classification_Type_descriptor(), name, value);
}
enum Lane_Classification_Subtype : int {
  Lane_Classification_Subtype_SUBTYPE_UNKNOWN = 0,
  Lane_Classification_Subtype_SUBTYPE_OTHER = 1,
  Lane_Classification_Subtype_SUBTYPE_NORMAL = 2,
  Lane_Classification_Subtype_SUBTYPE_BIKING = 3,
  Lane_Classification_Subtype_SUBTYPE_SIDEWALK = 4,
  Lane_Classification_Subtype_SUBTYPE_PARKING = 5,
  Lane_Classification_Subtype_SUBTYPE_STOP = 6,
  Lane_Classification_Subtype_SUBTYPE_RESTRICTED = 7,
  Lane_Classification_Subtype_SUBTYPE_BORDER = 8,
  Lane_Classification_Subtype_SUBTYPE_SHOULDER = 9,
  Lane_Classification_Subtype_SUBTYPE_EXIT = 10,
  Lane_Classification_Subtype_SUBTYPE_ENTRY = 11,
  Lane_Classification_Subtype_SUBTYPE_ONRAMP = 12,
  Lane_Classification_Subtype_SUBTYPE_OFFRAMP = 13,
  Lane_Classification_Subtype_SUBTYPE_CONNECTINGRAMP = 14,
  Lane_Classification_Subtype_Lane_Classification_Subtype_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Lane_Classification_Subtype_Lane_Classification_Subtype_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Lane_Classification_Subtype_IsValid(int value);
constexpr Lane_Classification_Subtype Lane_Classification_Subtype_Subtype_MIN = Lane_Classification_Subtype_SUBTYPE_UNKNOWN;
constexpr Lane_Classification_Subtype Lane_Classification_Subtype_Subtype_MAX = Lane_Classification_Subtype_SUBTYPE_CONNECTINGRAMP;
constexpr int Lane_Classification_Subtype_Subtype_ARRAYSIZE = Lane_Classification_Subtype_Subtype_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Lane_Classification_Subtype_descriptor();
template<typename T>
inline const std::string& Lane_Classification_Subtype_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Lane_Classification_Subtype>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Lane_Classification_Subtype_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Lane_Classification_Subtype_descriptor(), enum_t_value);
}
inline bool Lane_Classification_Subtype_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Lane_Classification_Subtype* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Lane_Classification_Subtype>(
    Lane_Classification_Subtype_descriptor(), name, value);
}
enum LaneBoundary_Classification_Type : int {
  LaneBoundary_Classification_Type_TYPE_UNKNOWN = 0,
  LaneBoundary_Classification_Type_TYPE_OTHER = 1,
  LaneBoundary_Classification_Type_TYPE_NO_LINE = 2,
  LaneBoundary_Classification_Type_TYPE_SOLID_LINE = 3,
  LaneBoundary_Classification_Type_TYPE_DASHED_LINE = 4,
  LaneBoundary_Classification_Type_TYPE_BOTTS_DOTS = 5,
  LaneBoundary_Classification_Type_TYPE_ROAD_EDGE = 6,
  LaneBoundary_Classification_Type_TYPE_SNOW_EDGE = 7,
  LaneBoundary_Classification_Type_TYPE_GRASS_EDGE = 8,
  LaneBoundary_Classification_Type_TYPE_GRAVEL_EDGE = 9,
  LaneBoundary_Classification_Type_TYPE_SOIL_EDGE = 10,
  LaneBoundary_Classification_Type_TYPE_GUARD_RAIL = 11,
  LaneBoundary_Classification_Type_TYPE_CURB = 12,
  LaneBoundary_Classification_Type_TYPE_STRUCTURE = 13,
  LaneBoundary_Classification_Type_LaneBoundary_Classification_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LaneBoundary_Classification_Type_LaneBoundary_Classification_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LaneBoundary_Classification_Type_IsValid(int value);
constexpr LaneBoundary_Classification_Type LaneBoundary_Classification_Type_Type_MIN = LaneBoundary_Classification_Type_TYPE_UNKNOWN;
constexpr LaneBoundary_Classification_Type LaneBoundary_Classification_Type_Type_MAX = LaneBoundary_Classification_Type_TYPE_STRUCTURE;
constexpr int LaneBoundary_Classification_Type_Type_ARRAYSIZE = LaneBoundary_Classification_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LaneBoundary_Classification_Type_descriptor();
template<typename T>
inline const std::string& LaneBoundary_Classification_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LaneBoundary_Classification_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LaneBoundary_Classification_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LaneBoundary_Classification_Type_descriptor(), enum_t_value);
}
inline bool LaneBoundary_Classification_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LaneBoundary_Classification_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LaneBoundary_Classification_Type>(
    LaneBoundary_Classification_Type_descriptor(), name, value);
}
enum LaneBoundary_Classification_Color : int {
  LaneBoundary_Classification_Color_COLOR_UNKNOWN = 0,
  LaneBoundary_Classification_Color_COLOR_OTHER = 1,
  LaneBoundary_Classification_Color_COLOR_NONE = 2,
  LaneBoundary_Classification_Color_COLOR_WHITE = 3,
  LaneBoundary_Classification_Color_COLOR_YELLOW = 4,
  LaneBoundary_Classification_Color_COLOR_RED = 5,
  LaneBoundary_Classification_Color_COLOR_BLUE = 6,
  LaneBoundary_Classification_Color_COLOR_GREEN = 7,
  LaneBoundary_Classification_Color_COLOR_VIOLET = 8,
  LaneBoundary_Classification_Color_LaneBoundary_Classification_Color_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LaneBoundary_Classification_Color_LaneBoundary_Classification_Color_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LaneBoundary_Classification_Color_IsValid(int value);
constexpr LaneBoundary_Classification_Color LaneBoundary_Classification_Color_Color_MIN = LaneBoundary_Classification_Color_COLOR_UNKNOWN;
constexpr LaneBoundary_Classification_Color LaneBoundary_Classification_Color_Color_MAX = LaneBoundary_Classification_Color_COLOR_VIOLET;
constexpr int LaneBoundary_Classification_Color_Color_ARRAYSIZE = LaneBoundary_Classification_Color_Color_MAX + 1;

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kSurfaceTemperatureFieldNumber = 1,
    kSurfaceWaterFilmFieldNumber = 2,
    kSurfaceFreezingPointFieldNumber = 3,
    kSurfaceIceFieldNumber = 4,
    kSurfaceRoughnessFieldNumber = 5,
    kSurfaceTextureFieldNumber = 6,
  };
  // double surface_temperature = 1;
  void clear_surface_temperature();
  double surface_temperature() const;
  void set_surface_temperature(double value);
  private:
  double _internal_surface_temperature() const;
  void _internal_set_surface_temperature(double value);
  public:

  // double surface_water_film = 2;
  void clear_surface_water_film();
  double surface_water_film() const;
  void set_surface_water_film(double value);
  private:
  double _internal_surface_water_film() const;
  void _internal_set_surface_water_film(double value);
  public:

  // double surface_freezing_point = 3;
  void clear_surface_freezing_point();
  double surface_freezing_point() const;
  void set_surface_freezing_point(double value);
  private:
  double _internal_surface_freezing_point() const;
  void _internal_set_surface_freezing_point(double value);
  public:

  // double surface_ice = 4;
  void clear_surface_ice();
  double surface_ice() const;
  void set_surface_ice(double value);
  private:
  double _internal_surface_ice() const;
  void _internal_set_surface_ice(double value);
  public:

  // double surface_roughness = 5;
  void clear_surface_roughness();
  double surface_roughness() const;
  void set_surface_roughness(double value);
  private:
  double _internal_surface_roughness() const;
  void _internal_set_surface_roughness(double value);
  public:

  // double surface_texture = 6;
  void clear_surface_texture();
  double surface_texture() const;
  void set_surface_texture(double value);
  private:
  double _internal_surface_texture() const;
  void _internal_set_surface_texture(double value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.Lane.Classification.RoadCondition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  double surface_temperature_;
  double surface_water_film_;
  double surface_freezing_point_;
  double surface_ice_;
  double surface_roughness_;
  double surface_texture_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kAntecessorLaneIdFieldNumber = 1,
    kSuccessorLaneIdFieldNumber = 2,
  };
  // .osi3.Identifier antecessor_lane_id = 1;
  bool has_antecessor_lane_id() const;
  private:
  bool _internal_has_antecessor_lane_id() const;
  public:
  void clear_antecessor_lane_id();
  const ::osi3::Identifier& antecessor_lane_id() const;
  ::osi3::Identifier* release_antecessor_lane_id();
  ::osi3::Identifier* mutable_antecessor_lane_id();
  void set_allocated_antecessor_lane_id(::osi3::Identifier* antecessor_lane_id);
  private:
  const ::osi3::Identifier& _internal_antecessor_lane_id() const;
  ::osi3::Identifier* _internal_mutable_antecessor_lane_id();
  public:
  void unsafe_arena_set_allocated_antecessor_lane_id(
      ::osi3::Identifier* antecessor_lane_id);
  ::osi3::Identifier* unsafe_arena_release_antecessor_lane_id();

  // .osi3.Identifier successor_lane_id = 2;
  bool has_successor_lane_id() const;
  private:
  bool _internal_has_successor_lane_id() const;
  public:
  void clear_successor_lane_id();
  const ::osi3::Identifier& successor_lane_id() const;
  ::osi3::Identifier* release_successor_lane_id();
  ::osi3::Identifier* mutable_successor_lane_id();
  void set_allocated_successor_lane_id(::osi3::Identifier* successor_lane_id);
  private:
  const ::osi3::Identifier& _internal_successor_lane_id() const;
  ::osi3::Identifier* _internal_mutable_successor_lane_id();
  public:
  void unsafe_arena_set_allocated_successor_lane_id(
      ::osi3::Identifier* successor_lane_id);
  ::osi3::Identifier* unsafe_arena_release_successor_lane_id();

  // @@protoc_insertion_point(class_scope:osi3.Lane.Classification.LanePairing)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Identifier* antecessor_lane_id_;
  ::osi3::Identifier* successor_lane_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

  typedef Lane_Classification_RoadCondition RoadCondition;
  typedef Lane_Classification_LanePairing LanePairing;

  typedef Lane_Classification_Type Type;
  static constexpr Type TYPE_UNKNOWN =
    Lane_Classification_Type_TYPE_UNKNOWN;
  static constexpr Type TYPE_OTHER =
    Lane_Classification_Type_TYPE_OTHER;
  static constexpr Type TYPE_DRIVING =
    Lane_Classification_Type_TYPE_DRIVING;
  static constexpr Type TYPE_NONDRIVING =
    Lane_Classification_Type_TYPE_NONDRIVING;
  static constexpr Type TYPE_INTERSECTION =
    Lane_Classification_Type_TYPE_INTERSECTION;
  static inline bool Type_IsValid(int value) {
    return Lane_Classification_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Lane_Classification_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Lane_Classification_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Lane_Classification_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Lane_Classification_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Lane_Classification_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Lane_Classification_Type_Parse(name, value);
  }

  typedef Lane_Classification_Subtype Subtype;
  static constexpr Subtype SUBTYPE_UNKNOWN =
    Lane_Classification_Subtype_SUBTYPE_UNKNOWN;
  static constexpr Subtype SUBTYPE_OTHER =
    Lane_Classification_Subtype_SUBTYPE_OTHER;
  static constexpr Subtype SUBTYPE_NORMAL =
    Lane_Classification_Subtype_SUBTYPE_NORMAL;
  static constexpr Subtype SUBTYPE_BIKING =
    Lane_Classification_Subtype_SUBTYPE_BIKING;
  static constexpr Subtype SUBTYPE_SIDEWALK =
    Lane_Classification_Subtype_SUBTYPE_SIDEWALK;
  static constexpr Subtype SUBTYPE_PARKING =
    Lane_Classification_Subtype_SUBTYPE_PARKING;
  static constexpr Subtype SUBTYPE_STOP =
    Lane_Classification_Subtype_SUBTYPE_STOP;
  static constexpr Subtype SUBTYPE_RESTRICTED =
    Lane_Classification_Subtype_SUBTYPE_RESTRICTED;
  static constexpr Subtype SUBTYPE_BORDER =
    Lane_Classification_Subtype_SUBTYPE_BORDER;
  static constexpr Subtype SUBTYPE_SHOULDER =
    Lane_Classification_Subtype_SUBTYPE_SHOULDER;
  static constexpr Subtype SUBTYPE_EXIT =
    Lane_Classification_Subtype_SUBTYPE_EXIT;
  static constexpr Subtype SUBTYPE_ENTRY =
    Lane_Classification_Subtype_SUBTYPE_ENTRY;
  static constexpr Subtype SUBTYPE_ONRAMP =
    Lane_Classification_Subtype_SUBTYPE_ONRAMP;
  static constexpr Subtype SUBTYPE_OFFRAMP =
    Lane_Classification_Subtype_SUBTYPE_OFFRAMP;
  static constexpr Subtype SUBTYPE_CONNECTINGRAMP =
    Lane_Classification_Subtype_SUBTYPE_CONNECTINGRAMP;
  static inline bool Subtype_IsValid(int value) {
    return Lane_Classification_Subtype_IsValid(value);
  }
  static constexpr Subtype Subtype_MIN =
    Lane_Classification_Subtype_Subtype_MIN;
  static constexpr Subtype Subtype_MAX =
    Lane_Classification_Subtype_Subtype_MAX;
  static constexpr int Subtype_ARRAYSIZE =
    Lane_Classification_Subtype_Subtype_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Subtype_descriptor() {
    return Lane_Classification_Subtype_descriptor();
  }
  template<typename T>
  static inline const std::string& Subtype_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Subtype>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Subtype_Name.");
    return Lane_Classification_Subtype_Name(enum_t_value);
  }
  static inline bool Subtype_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Subtype* value) {
    return Lane_Classification_Subtype_Parse(name, value);
  }

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

  enum : int {
    kCenterlineFieldNumber = 3,
    kLeftAdjacentLaneIdFieldNumber = 5,
    kRightAdjacentLaneIdFieldNumber = 6,
    kLanePairingFieldNumber = 7,
    kRightLaneBoundaryIdFieldNumber = 8,
    kLeftLaneBoundaryIdFieldNumber = 9,
    kFreeLaneBoundaryIdFieldNumber = 10,
    kRoadConditionFieldNumber = 11,
    kTypeFieldNumber = 1,
    kIsHostVehicleLaneFieldNumber = 2,
    kCenterlineIsDrivingDirectionFieldNumber = 4,
    kSubtypeFieldNumber = 12,
  };
  // repeated .osi3.Vector3d centerline = 3;
  int centerline_size() const;
  private:
  int _internal_centerline_size() const;
  public:
  void clear_centerline();
  ::osi3::Vector3d* mutable_centerline(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector3d >*
      mutable_centerline();
  private:
  const ::osi3::Vector3d& _internal_centerline(int index) const;
  ::osi3::Vector3d* _internal_add_centerline();
  public:
  const ::osi3::Vector3d& centerline(int index) const;
  ::osi3::Vector3d* add_centerline();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector3d >&
      centerline() const;

  // repeated .osi3.Identifier left_adjacent_lane_id = 5;
  int left_adjacent_lane_id_size() const;
  private:
  int _internal_left_adjacent_lane_id_size() const;
  public:
  void clear_left_adjacent_lane_id();
  ::osi3::Identifier* mutable_left_adjacent_lane_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_left_adjacent_lane_id();
  private:
  const ::osi3::Identifier& _internal_left_adjacent_lane_id(int index) const;
  ::osi3::Identifier* _internal_add_left_adjacent_lane_id();
  public:
  const ::osi3::Identifier& left_adjacent_lane_id(int index) const;
  ::osi3::Identifier* add_left_adjacent_lane_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      left_adjacent_lane_id() const;

  // repeated .osi3.Identifier right_adjacent_lane_id = 6;
  int right_adjacent_lane_id_size() const;
  private:
  int _internal_right_adjacent_lane_id_size() const;
  public:
  void clear_right_adjacent_lane_id();
  ::osi3::Identifier* mutable_right_adjacent_lane_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_right_adjacent_lane_id();
  private:
  const ::osi3::Identifier& _internal_right_adjacent_lane_id(int index) const;
  ::osi3::Identifier* _internal_add_right_adjacent_lane_id();
  public:
  const ::osi3::Identifier& right_adjacent_lane_id(int index) const;
  ::osi3::Identifier* add_right_adjacent_lane_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      right_adjacent_lane_id() const;

  // repeated .osi3.Lane.Classification.LanePairing lane_pairing = 7;
  int lane_pairing_size() const;
  private:
  int _internal_lane_pairing_size() const;
  public:
  void clear_lane_pairing();
  ::osi3::Lane_Classification_LanePairing* mutable_lane_pairing(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Lane_Classification_LanePairing >*
      mutable_lane_pairing();
  private:
  const ::osi3::Lane_Classification_LanePairing& _internal_lane_pairing(int index) const;
  ::osi3::Lane_Classification_LanePairing* _internal_add_lane_pairing();
  public:
  const ::osi3::Lane_Classification_LanePairing& lane_pairing(int index) const;
  ::osi3::Lane_Classification_LanePairing* add_lane_pairing();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Lane_Classification_LanePairing >&
      lane_pairing() const;

  // repeated .osi3.Identifier right_lane_boundary_id = 8;
  int right_lane_boundary_id_size() const;
  private:
  int _internal_right_lane_boundary_id_size() const;
  public:
  void clear_right_lane_boundary_id();
  ::osi3::Identifier* mutable_right_lane_boundary_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_right_lane_boundary_id();
  private:
  const ::osi3::Identifier& _internal_right_lane_boundary_id(int index) const;
  ::osi3::Identifier* _internal_add_right_lane_boundary_id();
  public:
  const ::osi3::Identifier& right_lane_boundary_id(int index) const;
  ::osi3::Identifier* add_right_lane_boundary_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      right_lane_boundary_id() const;

  // repeated .osi3.Identifier left_lane_boundary_id = 9;
  int left_lane_boundary_id_size() const;
  private:
  int _internal_left_lane_boundary_id_size() const;
  public:
  void clear_left_lane_boundary_id();
  ::osi3::Identifier* mutable_left_lane_boundary_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_left_lane_boundary_id();
  private:
  const ::osi3::Identifier& _internal_left_lane_boundary_id(int index) const;
  ::osi3::Identifier* _internal_add_left_lane_boundary_id();
  public:
  const ::osi3::Identifier& left_lane_boundary_id(int index) const;
  ::osi3::Identifier* add_left_lane_boundary_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      left_lane_boundary_id() const;

  // repeated .osi3.Identifier free_lane_boundary_id = 10;
  int free_lane_boundary_id_size() const;
  private:
  int _internal_free_lane_boundary_id_size() const;
  public:
  void clear_free_lane_boundary_id();
  ::osi3::Identifier* mutable_free_lane_boundary_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_free_lane_boundary_id();
  private:
  const ::osi3::Identifier& _internal_free_lane_boundary_id(int index) const;
  ::osi3::Identifier* _internal_add_free_lane_boundary_id();
  public:
  const ::osi3::Identifier& free_lane_boundary_id(int index) const;
  ::osi3::Identifier* add_free_lane_boundary_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      free_lane_boundary_id() const;

  // .osi3.Lane.Classification.RoadCondition road_condition = 11;
  bool has_road_condition() const;
  private:
  bool _internal_has_road_condition() const;
  public:
  void clear_road_condition();
  const ::osi3::Lane_Classification_RoadCondition& road_condition() const;
  ::osi3::Lane_Classification_RoadCondition* release_road_condition();
  ::osi3::Lane_Classification_RoadCondition* mutable_road_condition();
  void set_allocated_road_condition(::osi3::Lane_Classification_RoadCondition* road_condition);
  private:
  const ::osi3::Lane_Classification_RoadCondition& _internal_road_condition() const;
  ::osi3::Lane_Classification_RoadCondition* _internal_mutable_road_condition();
  public:
  void unsafe_arena_set_allocated_road_condition(
      ::osi3::Lane_Classification_RoadCondition* road_condition);
  ::osi3::Lane_Classification_RoadCondition* unsafe_arena_release_road_condition();

  // .osi3.Lane.Classification.Type type = 1;
  void clear_type();
  ::osi3::Lane_Classification_Type type() const;
  void set_type(::osi3::Lane_Classification_Type value);
  private:
  ::osi3::Lane_Classification_Type _internal_type() const;
  void _internal_set_type(::osi3::Lane_Classification_Type value);
  public:

  // bool is_host_vehicle_lane = 2;
  void clear_is_host_vehicle_lane();
  bool is_host_vehicle_lane() const;
  void set_is_host_vehicle_lane(bool value);
  private:
  bool _internal_is_host_vehicle_lane() const;
  void _internal_set_is_host_vehicle_lane(bool value);
  public:

  // bool centerline_is_driving_direction = 4;
  void clear_centerline_is_driving_direction();
  bool centerline_is_driving_direction() const;
  void set_centerline_is_driving_direction(bool value);
  private:
  bool _internal_centerline_is_driving_direction() const;
  void _internal_set_centerline_is_driving_direction(bool value);
  public:

  // .osi3.Lane.Classification.Subtype subtype = 12;
  void clear_subtype();
  ::osi3::Lane_Classification_Subtype subtype() const;
  void set_subtype(::osi3::Lane_Classification_Subtype value);
  private:
  ::osi3::Lane_Classification_Subtype _internal_subtype() const;
  void _internal_set_subtype(::osi3::Lane_Classification_Subtype value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector3d > centerline_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > left_adjacent_lane_id_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > right_adjacent_lane_id_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Lane_Classification_LanePairing > lane_pairing_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > right_lane_boundary_id_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > left_lane_boundary_id_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > free_lane_boundary_id_;
  ::osi3::Lane_Classification_RoadCondition* road_condition_;
  int type_;
  bool is_host_vehicle_lane_;
  bool centerline_is_driving_direction_;
  int subtype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

  typedef Lane_Classification Classification;

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

  enum : int {
    kIdFieldNumber = 1,
    kClassificationFieldNumber = 2,
  };
  // .osi3.Identifier id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const ::osi3::Identifier& id() const;
  ::osi3::Identifier* release_id();
  ::osi3::Identifier* mutable_id();
  void set_allocated_id(::osi3::Identifier* id);
  private:
  const ::osi3::Identifier& _internal_id() const;
  ::osi3::Identifier* _internal_mutable_id();
  public:
  void unsafe_arena_set_allocated_id(
      ::osi3::Identifier* id);
  ::osi3::Identifier* unsafe_arena_release_id();

  // .osi3.Lane.Classification classification = 2;
  bool has_classification() const;
  private:
  bool _internal_has_classification() const;
  public:
  void clear_classification();
  const ::osi3::Lane_Classification& classification() const;
  ::osi3::Lane_Classification* release_classification();
  ::osi3::Lane_Classification* mutable_classification();
  void set_allocated_classification(::osi3::Lane_Classification* classification);
  private:
  const ::osi3::Lane_Classification& _internal_classification() const;
  ::osi3::Lane_Classification* _internal_mutable_classification();
  public:
  void unsafe_arena_set_allocated_classification(
      ::osi3::Lane_Classification* classification);
  ::osi3::Lane_Classification* unsafe_arena_release_classification();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Identifier* id_;
  ::osi3::Lane_Classification* classification_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public:

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

  typedef LaneBoundary_Classification_Type Type;
  static constexpr Type TYPE_UNKNOWN =
    LaneBoundary_Classification_Type_TYPE_UNKNOWN;
  static constexpr Type TYPE_OTHER =
    LaneBoundary_Classification_Type_TYPE_OTHER;
  static constexpr Type TYPE_NO_LINE =
    LaneBoundary_Classification_Type_TYPE_NO_LINE;
  static constexpr Type TYPE_SOLID_LINE =
    LaneBoundary_Classification_Type_TYPE_SOLID_LINE;
  static constexpr Type TYPE_DASHED_LINE =
    LaneBoundary_Classification_Type_TYPE_DASHED_LINE;
  static constexpr Type TYPE_BOTTS_DOTS =
    LaneBoundary_Classification_Type_TYPE_BOTTS_DOTS;
  static constexpr Type TYPE_ROAD_EDGE =
    LaneBoundary_Classification_Type_TYPE_ROAD_EDGE;
  static constexpr Type TYPE_SNOW_EDGE =
    LaneBoundary_Classification_Type_TYPE_SNOW_EDGE;
  static constexpr Type TYPE_GRASS_EDGE =
    LaneBoundary_Classification_Type_TYPE_GRASS_EDGE;
  static constexpr Type TYPE_GRAVEL_EDGE =
    LaneBoundary_Classification_Type_TYPE_GRAVEL_EDGE;
  static constexpr Type TYPE_SOIL_EDGE =
    LaneBoundary_Classification_Type_TYPE_SOIL_EDGE;
  static constexpr Type TYPE_GUARD_RAIL =
    LaneBoundary_Classification_Type_TYPE_GUARD_RAIL;
  static constexpr Type TYPE_CURB =
    LaneBoundary_Classification_Type_TYPE_CURB;
  static constexpr Type TYPE_STRUCTURE =
    LaneBoundary_Classification_Type_TYPE_STRUCTURE;
  static inline bool Type_IsValid(int value) {
    return LaneBoundary_Classification_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    LaneBoundary_Classification_Type_Type_MIN;
  static constexpr Type Type_MAX =
    LaneBoundary_Classification_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    LaneBoundary_Classification_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return LaneBoundary_Classification_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return LaneBoundary_Classification_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return LaneBoundary_Classification_Type_Parse(name, value);
  }

  typedef LaneBoundary_Classification_Color Color;
  static constexpr Color COLOR_UNKNOWN =
    LaneBoundary_Classification_Color_COLOR_UNKNOWN;
  static constexpr Color COLOR_OTHER =
    LaneBoundary_Classification_Color_COLOR_OTHER;
  static constexpr Color COLOR_NONE =
    LaneBoundary_Classification_Color_COLOR_NONE;
  static constexpr Color COLOR_WHITE =
    LaneBoundary_Classification_Color_COLOR_WHITE;
  static constexpr Color COLOR_YELLOW =
    LaneBoundary_Classification_Color_COLOR_YELLOW;
  static constexpr Color COLOR_RED =
    LaneBoundary_Classification_Color_COLOR_RED;
  static constexpr Color COLOR_BLUE =
    LaneBoundary_Classification_Color_COLOR_BLUE;
  static constexpr Color COLOR_GREEN =
    LaneBoundary_Classification_Color_COLOR_GREEN;
  static constexpr Color COLOR_VIOLET =
    LaneBoundary_Classification_Color_COLOR_VIOLET;
  static inline bool Color_IsValid(int value) {
    return LaneBoundary_Classification_Color_IsValid(value);
  }
  static constexpr Color Color_MIN =
    LaneBoundary_Classification_Color_Color_MIN;
  static constexpr Color Color_MAX =
    LaneBoundary_Classification_Color_Color_MAX;
  static constexpr int Color_ARRAYSIZE =
    LaneBoundary_Classification_Color_Color_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Color_descriptor() {
    return LaneBoundary_Classification_Color_descriptor();
  }
  template<typename T>
  static inline const std::string& Color_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Color>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Color_Name.");
    return LaneBoundary_Classification_Color_Name(enum_t_value);
  }
  static inline bool Color_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Color* value) {
    return LaneBoundary_Classification_Color_Parse(name, value);
  }

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

  enum : int {
    kLimitingStructureIdFieldNumber = 3,
    kTypeFieldNumber = 1,
    kColorFieldNumber = 2,
  };
  // repeated .osi3.Identifier limiting_structure_id = 3;
  int limiting_structure_id_size() const;
  private:
  int _internal_limiting_structure_id_size() const;
  public:
  void clear_limiting_structure_id();
  ::osi3::Identifier* mutable_limiting_structure_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_limiting_structure_id();
  private:
  const ::osi3::Identifier& _internal_limiting_structure_id(int index) const;
  ::osi3::Identifier* _internal_add_limiting_structure_id();
  public:
  const ::osi3::Identifier& limiting_structure_id(int index) const;
  ::osi3::Identifier* add_limiting_structure_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      limiting_structure_id() const;

  // .osi3.LaneBoundary.Classification.Type type = 1;
  void clear_type();
  ::osi3::LaneBoundary_Classification_Type type() const;
  void set_type(::osi3::LaneBoundary_Classification_Type value);
  private:
  ::osi3::LaneBoundary_Classification_Type _internal_type() const;
  void _internal_set_type(::osi3::LaneBoundary_Classification_Type value);
  public:

  // .osi3.LaneBoundary.Classification.Color color = 2;
  void clear_color();
  ::osi3::LaneBoundary_Classification_Color color() const;
  void set_color(::osi3::LaneBoundary_Classification_Color value);
  private:
  ::osi3::LaneBoundary_Classification_Color _internal_color() const;
  void _internal_set_color(::osi3::LaneBoundary_Classification_Color value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier > limiting_structure_id_;
  int type_;
  int color_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

  typedef LaneBoundary_BoundaryPoint BoundaryPoint;
  typedef LaneBoundary_Classification Classification;

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

  enum : int {
    kBoundaryLineFieldNumber = 2,
    kIdFieldNumber = 1,
    kClassificationFieldNumber = 3,
  };
  // repeated .osi3.LaneBoundary.BoundaryPoint boundary_line = 2;
  int boundary_line_size() const;
  private:
  int _internal_boundary_line_size() const;
  public:
  void clear_boundary_line();
  ::osi3::LaneBoundary_BoundaryPoint* mutable_boundary_line(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::LaneBoundary_BoundaryPoint >*
      mutable_boundary_line();
  private:
  const ::osi3::LaneBoundary_BoundaryPoint& _internal_boundary_line(int index) const;
  ::osi3::LaneBoundary_BoundaryPoint* _internal_add_boundary_line();
  public:
  const ::osi3::LaneBoundary_BoundaryPoint& boundary_line(int index) const;
  ::osi3::LaneBoundary_BoundaryPoint* add_boundary_line();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::LaneBoundary_BoundaryPoint >&
      boundary_line() const;

  // .osi3.Identifier id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const ::osi3::Identifier& id() const;
  ::osi3::Identifier* release_id();
  ::osi3::Identifier* mutable_id();
  void set_allocated_id(::osi3::Identifier* id);
  private:
  const ::osi3::Identifier& _internal_id() const;
  ::osi3::Identifier* _internal_mutable_id();
  public:
  void unsafe_arena_set_allocated_id(
      ::osi3::Identifier* id);
  ::osi3::Identifier* unsafe_arena_release_id();

  // .osi3.LaneBoundary.Classification classification = 3;
  bool has_classification() const;
  private:
  bool _internal_has_classification() const;
  public:
  void clear_classification();
  const ::osi3::LaneBoundary_Classification& classification() const;
  ::osi3::LaneBoundary_Classification* release_classification();
  ::osi3::LaneBoundary_Classification* mutable_classification();
  void set_allocated_classification(::osi3::LaneBoundary_Classification* classification);
  private:
  const ::osi3::LaneBoundary_Classification& _internal_classification() const;
  ::osi3::LaneBoundary_Classification* _internal_mutable_classification();
  public:
  void unsafe_arena_set_allocated_classification(
      ::osi3::LaneBoundary_Classification* classification);
  ::osi3::LaneBoundary_Classification* unsafe_arena_release_classification();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::LaneBoundary_BoundaryPoint > boundary_line_;
  ::osi3::Identifier* id_;
  ::osi3::LaneBoundary_Classification* classification_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5flane_2eproto;
};
// ===================================================================


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

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

// double surface_temperature = 1;
inline void Lane_Classification_RoadCondition::clear_surface_temperature() {
  surface_temperature_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_temperature() const {
  return surface_temperature_;
}
inline double Lane_Classification_RoadCondition::surface_temperature() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_temperature)
  return _internal_surface_temperature();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_temperature(double value) {
  
  surface_temperature_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_temperature(double value) {
  _internal_set_surface_temperature(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_temperature)
}

// double surface_water_film = 2;
inline void Lane_Classification_RoadCondition::clear_surface_water_film() {
  surface_water_film_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_water_film() const {
  return surface_water_film_;
}
inline double Lane_Classification_RoadCondition::surface_water_film() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_water_film)
  return _internal_surface_water_film();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_water_film(double value) {
  
  surface_water_film_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_water_film(double value) {
  _internal_set_surface_water_film(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_water_film)
}

// double surface_freezing_point = 3;
inline void Lane_Classification_RoadCondition::clear_surface_freezing_point() {
  surface_freezing_point_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_freezing_point() const {
  return surface_freezing_point_;
}
inline double Lane_Classification_RoadCondition::surface_freezing_point() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_freezing_point)
  return _internal_surface_freezing_point();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_freezing_point(double value) {
  
  surface_freezing_point_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_freezing_point(double value) {
  _internal_set_surface_freezing_point(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_freezing_point)
}

// double surface_ice = 4;
inline void Lane_Classification_RoadCondition::clear_surface_ice() {
  surface_ice_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_ice() const {
  return surface_ice_;
}
inline double Lane_Classification_RoadCondition::surface_ice() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_ice)
  return _internal_surface_ice();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_ice(double value) {
  
  surface_ice_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_ice(double value) {
  _internal_set_surface_ice(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_ice)
}

// double surface_roughness = 5;
inline void Lane_Classification_RoadCondition::clear_surface_roughness() {
  surface_roughness_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_roughness() const {
  return surface_roughness_;
}
inline double Lane_Classification_RoadCondition::surface_roughness() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_roughness)
  return _internal_surface_roughness();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_roughness(double value) {
  
  surface_roughness_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_roughness(double value) {
  _internal_set_surface_roughness(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_roughness)
}

// double surface_texture = 6;
inline void Lane_Classification_RoadCondition::clear_surface_texture() {
  surface_texture_ = 0;
}
inline double Lane_Classification_RoadCondition::_internal_surface_texture() const {
  return surface_texture_;
}
inline double Lane_Classification_RoadCondition::surface_texture() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.RoadCondition.surface_texture)
  return _internal_surface_texture();
}
inline void Lane_Classification_RoadCondition::_internal_set_surface_texture(double value) {
  
  surface_texture_ = value;
}
inline void Lane_Classification_RoadCondition::set_surface_texture(double value) {
  _internal_set_surface_texture(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.RoadCondition.surface_texture)
}

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

// Lane_Classification_LanePairing

// .osi3.Identifier antecessor_lane_id = 1;
inline bool Lane_Classification_LanePairing::_internal_has_antecessor_lane_id() const {
  return this != internal_default_instance() && antecessor_lane_id_ != nullptr;
}
inline bool Lane_Classification_LanePairing::has_antecessor_lane_id() const {
  return _internal_has_antecessor_lane_id();
}
inline const ::osi3::Identifier& Lane_Classification_LanePairing::_internal_antecessor_lane_id() const {
  const ::osi3::Identifier* p = antecessor_lane_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Identifier&>(
      ::osi3::_Identifier_default_instance_);
}
inline const ::osi3::Identifier& Lane_Classification_LanePairing::antecessor_lane_id() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.LanePairing.antecessor_lane_id)
  return _internal_antecessor_lane_id();
}
inline void Lane_Classification_LanePairing::unsafe_arena_set_allocated_antecessor_lane_id(
    ::osi3::Identifier* antecessor_lane_id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(antecessor_lane_id_);
  }
  antecessor_lane_id_ = antecessor_lane_id;
  if (antecessor_lane_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.Lane.Classification.LanePairing.antecessor_lane_id)
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::release_antecessor_lane_id() {
  
  ::osi3::Identifier* temp = antecessor_lane_id_;
  antecessor_lane_id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::unsafe_arena_release_antecessor_lane_id() {
  // @@protoc_insertion_point(field_release:osi3.Lane.Classification.LanePairing.antecessor_lane_id)
  
  ::osi3::Identifier* temp = antecessor_lane_id_;
  antecessor_lane_id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::_internal_mutable_antecessor_lane_id() {
  
  if (antecessor_lane_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    antecessor_lane_id_ = p;
  }
  return antecessor_lane_id_;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::mutable_antecessor_lane_id() {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.LanePairing.antecessor_lane_id)
  return _internal_mutable_antecessor_lane_id();
}
inline void Lane_Classification_LanePairing::set_allocated_antecessor_lane_id(::osi3::Identifier* antecessor_lane_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(antecessor_lane_id_);
  }
  if (antecessor_lane_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(antecessor_lane_id)->GetArena();
    if (message_arena != submessage_arena) {
      antecessor_lane_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, antecessor_lane_id, submessage_arena);
    }
    
  } else {
    
  }
  antecessor_lane_id_ = antecessor_lane_id;
  // @@protoc_insertion_point(field_set_allocated:osi3.Lane.Classification.LanePairing.antecessor_lane_id)
}

// .osi3.Identifier successor_lane_id = 2;
inline bool Lane_Classification_LanePairing::_internal_has_successor_lane_id() const {
  return this != internal_default_instance() && successor_lane_id_ != nullptr;
}
inline bool Lane_Classification_LanePairing::has_successor_lane_id() const {
  return _internal_has_successor_lane_id();
}
inline const ::osi3::Identifier& Lane_Classification_LanePairing::_internal_successor_lane_id() const {
  const ::osi3::Identifier* p = successor_lane_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Identifier&>(
      ::osi3::_Identifier_default_instance_);
}
inline const ::osi3::Identifier& Lane_Classification_LanePairing::successor_lane_id() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.LanePairing.successor_lane_id)
  return _internal_successor_lane_id();
}
inline void Lane_Classification_LanePairing::unsafe_arena_set_allocated_successor_lane_id(
    ::osi3::Identifier* successor_lane_id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(successor_lane_id_);
  }
  successor_lane_id_ = successor_lane_id;
  if (successor_lane_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.Lane.Classification.LanePairing.successor_lane_id)
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::release_successor_lane_id() {
  
  ::osi3::Identifier* temp = successor_lane_id_;
  successor_lane_id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::unsafe_arena_release_successor_lane_id() {
  // @@protoc_insertion_point(field_release:osi3.Lane.Classification.LanePairing.successor_lane_id)
  
  ::osi3::Identifier* temp = successor_lane_id_;
  successor_lane_id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::_internal_mutable_successor_lane_id() {
  
  if (successor_lane_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    successor_lane_id_ = p;
  }
  return successor_lane_id_;
}
inline ::osi3::Identifier* Lane_Classification_LanePairing::mutable_successor_lane_id() {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.LanePairing.successor_lane_id)
  return _internal_mutable_successor_lane_id();
}
inline void Lane_Classification_LanePairing::set_allocated_successor_lane_id(::osi3::Identifier* successor_lane_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(successor_lane_id_);
  }
  if (successor_lane_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(successor_lane_id)->GetArena();
    if (message_arena != submessage_arena) {
      successor_lane_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, successor_lane_id, submessage_arena);
    }
    
  } else {
    
  }
  successor_lane_id_ = successor_lane_id;
  // @@protoc_insertion_point(field_set_allocated:osi3.Lane.Classification.LanePairing.successor_lane_id)
}

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

// Lane_Classification

// .osi3.Lane.Classification.Type type = 1;
inline void Lane_Classification::clear_type() {
  type_ = 0;
}
inline ::osi3::Lane_Classification_Type Lane_Classification::_internal_type() const {
  return static_cast< ::osi3::Lane_Classification_Type >(type_);
}
inline ::osi3::Lane_Classification_Type Lane_Classification::type() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.type)
  return _internal_type();
}
inline void Lane_Classification::_internal_set_type(::osi3::Lane_Classification_Type value) {
  
  type_ = value;
}
inline void Lane_Classification::set_type(::osi3::Lane_Classification_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.type)
}

// bool is_host_vehicle_lane = 2;
inline void Lane_Classification::clear_is_host_vehicle_lane() {
  is_host_vehicle_lane_ = false;
}
inline bool Lane_Classification::_internal_is_host_vehicle_lane() const {
  return is_host_vehicle_lane_;
}
inline bool Lane_Classification::is_host_vehicle_lane() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.is_host_vehicle_lane)
  return _internal_is_host_vehicle_lane();
}
inline void Lane_Classification::_internal_set_is_host_vehicle_lane(bool value) {
  
  is_host_vehicle_lane_ = value;
}
inline void Lane_Classification::set_is_host_vehicle_lane(bool value) {
  _internal_set_is_host_vehicle_lane(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.is_host_vehicle_lane)
}

// repeated .osi3.Vector3d centerline = 3;
inline int Lane_Classification::_internal_centerline_size() const {
  return centerline_.size();
}
inline int Lane_Classification::centerline_size() const {
  return _internal_centerline_size();
}
inline ::osi3::Vector3d* Lane_Classification::mutable_centerline(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.centerline)
  return centerline_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector3d >*
Lane_Classification::mutable_centerline() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.centerline)
  return &centerline_;
}
inline const ::osi3::Vector3d& Lane_Classification::_internal_centerline(int index) const {
  return centerline_.Get(index);
}
inline const ::osi3::Vector3d& Lane_Classification::centerline(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.centerline)
  return _internal_centerline(index);
}
inline ::osi3::Vector3d* Lane_Classification::_internal_add_centerline() {
  return centerline_.Add();
}
inline ::osi3::Vector3d* Lane_Classification::add_centerline() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.centerline)
  return _internal_add_centerline();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Vector3d >&
Lane_Classification::centerline() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.centerline)
  return centerline_;
}

// bool centerline_is_driving_direction = 4;
inline void Lane_Classification::clear_centerline_is_driving_direction() {
  centerline_is_driving_direction_ = false;
}
inline bool Lane_Classification::_internal_centerline_is_driving_direction() const {
  return centerline_is_driving_direction_;
}
inline bool Lane_Classification::centerline_is_driving_direction() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.centerline_is_driving_direction)
  return _internal_centerline_is_driving_direction();
}
inline void Lane_Classification::_internal_set_centerline_is_driving_direction(bool value) {
  
  centerline_is_driving_direction_ = value;
}
inline void Lane_Classification::set_centerline_is_driving_direction(bool value) {
  _internal_set_centerline_is_driving_direction(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.centerline_is_driving_direction)
}

// repeated .osi3.Identifier left_adjacent_lane_id = 5;
inline int Lane_Classification::_internal_left_adjacent_lane_id_size() const {
  return left_adjacent_lane_id_.size();
}
inline int Lane_Classification::left_adjacent_lane_id_size() const {
  return _internal_left_adjacent_lane_id_size();
}
inline ::osi3::Identifier* Lane_Classification::mutable_left_adjacent_lane_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.left_adjacent_lane_id)
  return left_adjacent_lane_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
Lane_Classification::mutable_left_adjacent_lane_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.left_adjacent_lane_id)
  return &left_adjacent_lane_id_;
}
inline const ::osi3::Identifier& Lane_Classification::_internal_left_adjacent_lane_id(int index) const {
  return left_adjacent_lane_id_.Get(index);
}
inline const ::osi3::Identifier& Lane_Classification::left_adjacent_lane_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.left_adjacent_lane_id)
  return _internal_left_adjacent_lane_id(index);
}
inline ::osi3::Identifier* Lane_Classification::_internal_add_left_adjacent_lane_id() {
  return left_adjacent_lane_id_.Add();
}
inline ::osi3::Identifier* Lane_Classification::add_left_adjacent_lane_id() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.left_adjacent_lane_id)
  return _internal_add_left_adjacent_lane_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
Lane_Classification::left_adjacent_lane_id() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.left_adjacent_lane_id)
  return left_adjacent_lane_id_;
}

// repeated .osi3.Identifier right_adjacent_lane_id = 6;
inline int Lane_Classification::_internal_right_adjacent_lane_id_size() const {
  return right_adjacent_lane_id_.size();
}
inline int Lane_Classification::right_adjacent_lane_id_size() const {
  return _internal_right_adjacent_lane_id_size();
}
inline ::osi3::Identifier* Lane_Classification::mutable_right_adjacent_lane_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.right_adjacent_lane_id)
  return right_adjacent_lane_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
Lane_Classification::mutable_right_adjacent_lane_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.right_adjacent_lane_id)
  return &right_adjacent_lane_id_;
}
inline const ::osi3::Identifier& Lane_Classification::_internal_right_adjacent_lane_id(int index) const {
  return right_adjacent_lane_id_.Get(index);
}
inline const ::osi3::Identifier& Lane_Classification::right_adjacent_lane_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.right_adjacent_lane_id)
  return _internal_right_adjacent_lane_id(index);
}
inline ::osi3::Identifier* Lane_Classification::_internal_add_right_adjacent_lane_id() {
  return right_adjacent_lane_id_.Add();
}
inline ::osi3::Identifier* Lane_Classification::add_right_adjacent_lane_id() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.right_adjacent_lane_id)
  return _internal_add_right_adjacent_lane_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
Lane_Classification::right_adjacent_lane_id() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.right_adjacent_lane_id)
  return right_adjacent_lane_id_;
}

// repeated .osi3.Lane.Classification.LanePairing lane_pairing = 7;
inline int Lane_Classification::_internal_lane_pairing_size() const {
  return lane_pairing_.size();
}
inline int Lane_Classification::lane_pairing_size() const {
  return _internal_lane_pairing_size();
}
inline void Lane_Classification::clear_lane_pairing() {
  lane_pairing_.Clear();
}
inline ::osi3::Lane_Classification_LanePairing* Lane_Classification::mutable_lane_pairing(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.lane_pairing)
  return lane_pairing_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Lane_Classification_LanePairing >*
Lane_Classification::mutable_lane_pairing() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.lane_pairing)
  return &lane_pairing_;
}
inline const ::osi3::Lane_Classification_LanePairing& Lane_Classification::_internal_lane_pairing(int index) const {
  return lane_pairing_.Get(index);
}
inline const ::osi3::Lane_Classification_LanePairing& Lane_Classification::lane_pairing(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.lane_pairing)
  return _internal_lane_pairing(index);
}
inline ::osi3::Lane_Classification_LanePairing* Lane_Classification::_internal_add_lane_pairing() {
  return lane_pairing_.Add();
}
inline ::osi3::Lane_Classification_LanePairing* Lane_Classification::add_lane_pairing() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.lane_pairing)
  return _internal_add_lane_pairing();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Lane_Classification_LanePairing >&
Lane_Classification::lane_pairing() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.lane_pairing)
  return lane_pairing_;
}

// repeated .osi3.Identifier right_lane_boundary_id = 8;
inline int Lane_Classification::_internal_right_lane_boundary_id_size() const {
  return right_lane_boundary_id_.size();
}
inline int Lane_Classification::right_lane_boundary_id_size() const {
  return _internal_right_lane_boundary_id_size();
}
inline ::osi3::Identifier* Lane_Classification::mutable_right_lane_boundary_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.right_lane_boundary_id)
  return right_lane_boundary_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
Lane_Classification::mutable_right_lane_boundary_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.right_lane_boundary_id)
  return &right_lane_boundary_id_;
}
inline const ::osi3::Identifier& Lane_Classification::_internal_right_lane_boundary_id(int index) const {
  return right_lane_boundary_id_.Get(index);
}
inline const ::osi3::Identifier& Lane_Classification::right_lane_boundary_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.right_lane_boundary_id)
  return _internal_right_lane_boundary_id(index);
}
inline ::osi3::Identifier* Lane_Classification::_internal_add_right_lane_boundary_id() {
  return right_lane_boundary_id_.Add();
}
inline ::osi3::Identifier* Lane_Classification::add_right_lane_boundary_id() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.right_lane_boundary_id)
  return _internal_add_right_lane_boundary_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
Lane_Classification::right_lane_boundary_id() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.right_lane_boundary_id)
  return right_lane_boundary_id_;
}

// repeated .osi3.Identifier left_lane_boundary_id = 9;
inline int Lane_Classification::_internal_left_lane_boundary_id_size() const {
  return left_lane_boundary_id_.size();
}
inline int Lane_Classification::left_lane_boundary_id_size() const {
  return _internal_left_lane_boundary_id_size();
}
inline ::osi3::Identifier* Lane_Classification::mutable_left_lane_boundary_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.left_lane_boundary_id)
  return left_lane_boundary_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
Lane_Classification::mutable_left_lane_boundary_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.left_lane_boundary_id)
  return &left_lane_boundary_id_;
}
inline const ::osi3::Identifier& Lane_Classification::_internal_left_lane_boundary_id(int index) const {
  return left_lane_boundary_id_.Get(index);
}
inline const ::osi3::Identifier& Lane_Classification::left_lane_boundary_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.left_lane_boundary_id)
  return _internal_left_lane_boundary_id(index);
}
inline ::osi3::Identifier* Lane_Classification::_internal_add_left_lane_boundary_id() {
  return left_lane_boundary_id_.Add();
}
inline ::osi3::Identifier* Lane_Classification::add_left_lane_boundary_id() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.left_lane_boundary_id)
  return _internal_add_left_lane_boundary_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
Lane_Classification::left_lane_boundary_id() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.left_lane_boundary_id)
  return left_lane_boundary_id_;
}

// repeated .osi3.Identifier free_lane_boundary_id = 10;
inline int Lane_Classification::_internal_free_lane_boundary_id_size() const {
  return free_lane_boundary_id_.size();
}
inline int Lane_Classification::free_lane_boundary_id_size() const {
  return _internal_free_lane_boundary_id_size();
}
inline ::osi3::Identifier* Lane_Classification::mutable_free_lane_boundary_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.free_lane_boundary_id)
  return free_lane_boundary_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
Lane_Classification::mutable_free_lane_boundary_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.Lane.Classification.free_lane_boundary_id)
  return &free_lane_boundary_id_;
}
inline const ::osi3::Identifier& Lane_Classification::_internal_free_lane_boundary_id(int index) const {
  return free_lane_boundary_id_.Get(index);
}
inline const ::osi3::Identifier& Lane_Classification::free_lane_boundary_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.free_lane_boundary_id)
  return _internal_free_lane_boundary_id(index);
}
inline ::osi3::Identifier* Lane_Classification::_internal_add_free_lane_boundary_id() {
  return free_lane_boundary_id_.Add();
}
inline ::osi3::Identifier* Lane_Classification::add_free_lane_boundary_id() {
  // @@protoc_insertion_point(field_add:osi3.Lane.Classification.free_lane_boundary_id)
  return _internal_add_free_lane_boundary_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
Lane_Classification::free_lane_boundary_id() const {
  // @@protoc_insertion_point(field_list:osi3.Lane.Classification.free_lane_boundary_id)
  return free_lane_boundary_id_;
}

// .osi3.Lane.Classification.RoadCondition road_condition = 11;
inline bool Lane_Classification::_internal_has_road_condition() const {
  return this != internal_default_instance() && road_condition_ != nullptr;
}
inline bool Lane_Classification::has_road_condition() const {
  return _internal_has_road_condition();
}
inline void Lane_Classification::clear_road_condition() {
  if (GetArena() == nullptr && road_condition_ != nullptr) {
    delete road_condition_;
  }
  road_condition_ = nullptr;
}
inline const ::osi3::Lane_Classification_RoadCondition& Lane_Classification::_internal_road_condition() const {
  const ::osi3::Lane_Classification_RoadCondition* p = road_condition_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Lane_Classification_RoadCondition&>(
      ::osi3::_Lane_Classification_RoadCondition_default_instance_);
}
inline const ::osi3::Lane_Classification_RoadCondition& Lane_Classification::road_condition() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.road_condition)
  return _internal_road_condition();
}
inline void Lane_Classification::unsafe_arena_set_allocated_road_condition(
    ::osi3::Lane_Classification_RoadCondition* road_condition) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(road_condition_);
  }
  road_condition_ = road_condition;
  if (road_condition) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.Lane.Classification.road_condition)
}
inline ::osi3::Lane_Classification_RoadCondition* Lane_Classification::release_road_condition() {
  
  ::osi3::Lane_Classification_RoadCondition* temp = road_condition_;
  road_condition_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Lane_Classification_RoadCondition* Lane_Classification::unsafe_arena_release_road_condition() {
  // @@protoc_insertion_point(field_release:osi3.Lane.Classification.road_condition)
  
  ::osi3::Lane_Classification_RoadCondition* temp = road_condition_;
  road_condition_ = nullptr;
  return temp;
}
inline ::osi3::Lane_Classification_RoadCondition* Lane_Classification::_internal_mutable_road_condition() {
  
  if (road_condition_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Lane_Classification_RoadCondition>(GetArena());
    road_condition_ = p;
  }
  return road_condition_;
}
inline ::osi3::Lane_Classification_RoadCondition* Lane_Classification::mutable_road_condition() {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.Classification.road_condition)
  return _internal_mutable_road_condition();
}
inline void Lane_Classification::set_allocated_road_condition(::osi3::Lane_Classification_RoadCondition* road_condition) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete road_condition_;
  }
  if (road_condition) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(road_condition);
    if (message_arena != submessage_arena) {
      road_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, road_condition, submessage_arena);
    }
    
  } else {
    
  }
  road_condition_ = road_condition;
  // @@protoc_insertion_point(field_set_allocated:osi3.Lane.Classification.road_condition)
}

// .osi3.Lane.Classification.Subtype subtype = 12;
inline void Lane_Classification::clear_subtype() {
  subtype_ = 0;
}
inline ::osi3::Lane_Classification_Subtype Lane_Classification::_internal_subtype() const {
  return static_cast< ::osi3::Lane_Classification_Subtype >(subtype_);
}
inline ::osi3::Lane_Classification_Subtype Lane_Classification::subtype() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.Classification.subtype)
  return _internal_subtype();
}
inline void Lane_Classification::_internal_set_subtype(::osi3::Lane_Classification_Subtype value) {
  
  subtype_ = value;
}
inline void Lane_Classification::set_subtype(::osi3::Lane_Classification_Subtype value) {
  _internal_set_subtype(value);
  // @@protoc_insertion_point(field_set:osi3.Lane.Classification.subtype)
}

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

// Lane

// .osi3.Identifier id = 1;
inline bool Lane::_internal_has_id() const {
  return this != internal_default_instance() && id_ != nullptr;
}
inline bool Lane::has_id() const {
  return _internal_has_id();
}
inline const ::osi3::Identifier& Lane::_internal_id() const {
  const ::osi3::Identifier* p = id_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Identifier&>(
      ::osi3::_Identifier_default_instance_);
}
inline const ::osi3::Identifier& Lane::id() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.id)
  return _internal_id();
}
inline void Lane::unsafe_arena_set_allocated_id(
    ::osi3::Identifier* id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
  }
  id_ = id;
  if (id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.Lane.id)
}
inline ::osi3::Identifier* Lane::release_id() {
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* Lane::unsafe_arena_release_id() {
  // @@protoc_insertion_point(field_release:osi3.Lane.id)
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* Lane::_internal_mutable_id() {
  
  if (id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    id_ = p;
  }
  return id_;
}
inline ::osi3::Identifier* Lane::mutable_id() {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.id)
  return _internal_mutable_id();
}
inline void Lane::set_allocated_id(::osi3::Identifier* id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
  }
  if (id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena();
    if (message_arena != submessage_arena) {
      id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, id, submessage_arena);
    }
    
  } else {
    
  }
  id_ = id;
  // @@protoc_insertion_point(field_set_allocated:osi3.Lane.id)
}

// .osi3.Lane.Classification classification = 2;
inline bool Lane::_internal_has_classification() const {
  return this != internal_default_instance() && classification_ != nullptr;
}
inline bool Lane::has_classification() const {
  return _internal_has_classification();
}
inline void Lane::clear_classification() {
  if (GetArena() == nullptr && classification_ != nullptr) {
    delete classification_;
  }
  classification_ = nullptr;
}
inline const ::osi3::Lane_Classification& Lane::_internal_classification() const {
  const ::osi3::Lane_Classification* p = classification_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Lane_Classification&>(
      ::osi3::_Lane_Classification_default_instance_);
}
inline const ::osi3::Lane_Classification& Lane::classification() const {
  // @@protoc_insertion_point(field_get:osi3.Lane.classification)
  return _internal_classification();
}
inline void Lane::unsafe_arena_set_allocated_classification(
    ::osi3::Lane_Classification* classification) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(classification_);
  }
  classification_ = classification;
  if (classification) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.Lane.classification)
}
inline ::osi3::Lane_Classification* Lane::release_classification() {
  
  ::osi3::Lane_Classification* temp = classification_;
  classification_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Lane_Classification* Lane::unsafe_arena_release_classification() {
  // @@protoc_insertion_point(field_release:osi3.Lane.classification)
  
  ::osi3::Lane_Classification* temp = classification_;
  classification_ = nullptr;
  return temp;
}
inline ::osi3::Lane_Classification* Lane::_internal_mutable_classification() {
  
  if (classification_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Lane_Classification>(GetArena());
    classification_ = p;
  }
  return classification_;
}
inline ::osi3::Lane_Classification* Lane::mutable_classification() {
  // @@protoc_insertion_point(field_mutable:osi3.Lane.classification)
  return _internal_mutable_classification();
}
inline void Lane::set_allocated_classification(::osi3::Lane_Classification* classification) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete classification_;
  }
  if (classification) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(classification);
    if (message_arena != submessage_arena) {
      classification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, classification, submessage_arena);
    }
    
  } else {
    
  }
  classification_ = classification;
  // @@protoc_insertion_point(field_set_allocated:osi3.Lane.classification)
}

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

// LaneBoundary_BoundaryPoint

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

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

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

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

// LaneBoundary_Classification

// .osi3.LaneBoundary.Classification.Type type = 1;
inline void LaneBoundary_Classification::clear_type() {
  type_ = 0;
}
inline ::osi3::LaneBoundary_Classification_Type LaneBoundary_Classification::_internal_type() const {
  return static_cast< ::osi3::LaneBoundary_Classification_Type >(type_);
}
inline ::osi3::LaneBoundary_Classification_Type LaneBoundary_Classification::type() const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.Classification.type)
  return _internal_type();
}
inline void LaneBoundary_Classification::_internal_set_type(::osi3::LaneBoundary_Classification_Type value) {
  
  type_ = value;
}
inline void LaneBoundary_Classification::set_type(::osi3::LaneBoundary_Classification_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:osi3.LaneBoundary.Classification.type)
}

// .osi3.LaneBoundary.Classification.Color color = 2;
inline void LaneBoundary_Classification::clear_color() {
  color_ = 0;
}
inline ::osi3::LaneBoundary_Classification_Color LaneBoundary_Classification::_internal_color() const {
  return static_cast< ::osi3::LaneBoundary_Classification_Color >(color_);
}
inline ::osi3::LaneBoundary_Classification_Color LaneBoundary_Classification::color() const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.Classification.color)
  return _internal_color();
}
inline void LaneBoundary_Classification::_internal_set_color(::osi3::LaneBoundary_Classification_Color value) {
  
  color_ = value;
}
inline void LaneBoundary_Classification::set_color(::osi3::LaneBoundary_Classification_Color value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:osi3.LaneBoundary.Classification.color)
}

// repeated .osi3.Identifier limiting_structure_id = 3;
inline int LaneBoundary_Classification::_internal_limiting_structure_id_size() const {
  return limiting_structure_id_.size();
}
inline int LaneBoundary_Classification::limiting_structure_id_size() const {
  return _internal_limiting_structure_id_size();
}
inline ::osi3::Identifier* LaneBoundary_Classification::mutable_limiting_structure_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.LaneBoundary.Classification.limiting_structure_id)
  return limiting_structure_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
LaneBoundary_Classification::mutable_limiting_structure_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.LaneBoundary.Classification.limiting_structure_id)
  return &limiting_structure_id_;
}
inline const ::osi3::Identifier& LaneBoundary_Classification::_internal_limiting_structure_id(int index) const {
  return limiting_structure_id_.Get(index);
}
inline const ::osi3::Identifier& LaneBoundary_Classification::limiting_structure_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.Classification.limiting_structure_id)
  return _internal_limiting_structure_id(index);
}
inline ::osi3::Identifier* LaneBoundary_Classification::_internal_add_limiting_structure_id() {
  return limiting_structure_id_.Add();
}
inline ::osi3::Identifier* LaneBoundary_Classification::add_limiting_structure_id() {
  // @@protoc_insertion_point(field_add:osi3.LaneBoundary.Classification.limiting_structure_id)
  return _internal_add_limiting_structure_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
LaneBoundary_Classification::limiting_structure_id() const {
  // @@protoc_insertion_point(field_list:osi3.LaneBoundary.Classification.limiting_structure_id)
  return limiting_structure_id_;
}

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

// LaneBoundary

// .osi3.Identifier id = 1;
inline bool LaneBoundary::_internal_has_id() const {
  return this != internal_default_instance() && id_ != nullptr;
}
inline bool LaneBoundary::has_id() const {
  return _internal_has_id();
}
inline const ::osi3::Identifier& LaneBoundary::_internal_id() const {
  const ::osi3::Identifier* p = id_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::Identifier&>(
      ::osi3::_Identifier_default_instance_);
}
inline const ::osi3::Identifier& LaneBoundary::id() const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.id)
  return _internal_id();
}
inline void LaneBoundary::unsafe_arena_set_allocated_id(
    ::osi3::Identifier* id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
  }
  id_ = id;
  if (id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.LaneBoundary.id)
}
inline ::osi3::Identifier* LaneBoundary::release_id() {
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* LaneBoundary::unsafe_arena_release_id() {
  // @@protoc_insertion_point(field_release:osi3.LaneBoundary.id)
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* LaneBoundary::_internal_mutable_id() {
  
  if (id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    id_ = p;
  }
  return id_;
}
inline ::osi3::Identifier* LaneBoundary::mutable_id() {
  // @@protoc_insertion_point(field_mutable:osi3.LaneBoundary.id)
  return _internal_mutable_id();
}
inline void LaneBoundary::set_allocated_id(::osi3::Identifier* id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
  }
  if (id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena();
    if (message_arena != submessage_arena) {
      id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, id, submessage_arena);
    }
    
  } else {
    
  }
  id_ = id;
  // @@protoc_insertion_point(field_set_allocated:osi3.LaneBoundary.id)
}

// repeated .osi3.LaneBoundary.BoundaryPoint boundary_line = 2;
inline int LaneBoundary::_internal_boundary_line_size() const {
  return boundary_line_.size();
}
inline int LaneBoundary::boundary_line_size() const {
  return _internal_boundary_line_size();
}
inline void LaneBoundary::clear_boundary_line() {
  boundary_line_.Clear();
}
inline ::osi3::LaneBoundary_BoundaryPoint* LaneBoundary::mutable_boundary_line(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.LaneBoundary.boundary_line)
  return boundary_line_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::LaneBoundary_BoundaryPoint >*
LaneBoundary::mutable_boundary_line() {
  // @@protoc_insertion_point(field_mutable_list:osi3.LaneBoundary.boundary_line)
  return &boundary_line_;
}
inline const ::osi3::LaneBoundary_BoundaryPoint& LaneBoundary::_internal_boundary_line(int index) const {
  return boundary_line_.Get(index);
}
inline const ::osi3::LaneBoundary_BoundaryPoint& LaneBoundary::boundary_line(int index) const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.boundary_line)
  return _internal_boundary_line(index);
}
inline ::osi3::LaneBoundary_BoundaryPoint* LaneBoundary::_internal_add_boundary_line() {
  return boundary_line_.Add();
}
inline ::osi3::LaneBoundary_BoundaryPoint* LaneBoundary::add_boundary_line() {
  // @@protoc_insertion_point(field_add:osi3.LaneBoundary.boundary_line)
  return _internal_add_boundary_line();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::LaneBoundary_BoundaryPoint >&
LaneBoundary::boundary_line() const {
  // @@protoc_insertion_point(field_list:osi3.LaneBoundary.boundary_line)
  return boundary_line_;
}

// .osi3.LaneBoundary.Classification classification = 3;
inline bool LaneBoundary::_internal_has_classification() const {
  return this != internal_default_instance() && classification_ != nullptr;
}
inline bool LaneBoundary::has_classification() const {
  return _internal_has_classification();
}
inline void LaneBoundary::clear_classification() {
  if (GetArena() == nullptr && classification_ != nullptr) {
    delete classification_;
  }
  classification_ = nullptr;
}
inline const ::osi3::LaneBoundary_Classification& LaneBoundary::_internal_classification() const {
  const ::osi3::LaneBoundary_Classification* p = classification_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::LaneBoundary_Classification&>(
      ::osi3::_LaneBoundary_Classification_default_instance_);
}
inline const ::osi3::LaneBoundary_Classification& LaneBoundary::classification() const {
  // @@protoc_insertion_point(field_get:osi3.LaneBoundary.classification)
  return _internal_classification();
}
inline void LaneBoundary::unsafe_arena_set_allocated_classification(
    ::osi3::LaneBoundary_Classification* classification) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(classification_);
  }
  classification_ = classification;
  if (classification) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.LaneBoundary.classification)
}
inline ::osi3::LaneBoundary_Classification* LaneBoundary::release_classification() {
  
  ::osi3::LaneBoundary_Classification* temp = classification_;
  classification_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::LaneBoundary_Classification* LaneBoundary::unsafe_arena_release_classification() {
  // @@protoc_insertion_point(field_release:osi3.LaneBoundary.classification)
  
  ::osi3::LaneBoundary_Classification* temp = classification_;
  classification_ = nullptr;
  return temp;
}
inline ::osi3::LaneBoundary_Classification* LaneBoundary::_internal_mutable_classification() {
  
  if (classification_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::LaneBoundary_Classification>(GetArena());
    classification_ = p;
  }
  return classification_;
}
inline ::osi3::LaneBoundary_Classification* LaneBoundary::mutable_classification() {
  // @@protoc_insertion_point(field_mutable:osi3.LaneBoundary.classification)
  return _internal_mutable_classification();
}
inline void LaneBoundary::set_allocated_classification(::osi3::LaneBoundary_Classification* classification) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete classification_;
  }
  if (classification) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(classification);
    if (message_arena != submessage_arena) {
      classification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, classification, submessage_arena);
    }
    
  } else {
    
  }
  classification_ = classification;
  // @@protoc_insertion_point(field_set_allocated:osi3.LaneBoundary.classification)
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace osi3

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::osi3::Lane_Classification_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::Lane_Classification_Type>() {
  return ::osi3::Lane_Classification_Type_descriptor();
}
template <> struct is_proto_enum< ::osi3::Lane_Classification_Subtype> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::Lane_Classification_Subtype>() {
  return ::osi3::Lane_Classification_Subtype_descriptor();
}
template <> struct is_proto_enum< ::osi3::LaneBoundary_Classification_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::LaneBoundary_Classification_Type>() {
  return ::osi3::LaneBoundary_Classification_Type_descriptor();
}
template <> struct is_proto_enum< ::osi3::LaneBoundary_Classification_Color> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::LaneBoundary_Classification_Color>() {
  return ::osi3::LaneBoundary_Classification_Color_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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