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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_osi_5froadmarking_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_osi_5froadmarking_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_osi_5froadmarking_2eproto_metadata_getter(int index);
namespace osi3 {
class RoadMarking;
struct RoadMarkingDefaultTypeInternal;
extern RoadMarkingDefaultTypeInternal _RoadMarking_default_instance_;
class RoadMarking_Classification;
struct RoadMarking_ClassificationDefaultTypeInternal;
extern RoadMarking_ClassificationDefaultTypeInternal _RoadMarking_Classification_default_instance_;
}  // namespace osi3
PROTOBUF_NAMESPACE_OPEN
template<> ::osi3::RoadMarking* Arena::CreateMaybeMessage<::osi3::RoadMarking>(Arena*);
template<> ::osi3::RoadMarking_Classification* Arena::CreateMaybeMessage<::osi3::RoadMarking_Classification>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace osi3 {

enum RoadMarking_Classification_Type : int {
  RoadMarking_Classification_Type_TYPE_UNKNOWN = 0,
  RoadMarking_Classification_Type_TYPE_OTHER = 1,
  RoadMarking_Classification_Type_TYPE_PAINTED_TRAFFIC_SIGN = 2,
  RoadMarking_Classification_Type_TYPE_SYMBOLIC_TRAFFIC_SIGN = 3,
  RoadMarking_Classification_Type_TYPE_TEXTUAL_TRAFFIC_SIGN = 4,
  RoadMarking_Classification_Type_TYPE_GENERIC_SYMBOL = 5,
  RoadMarking_Classification_Type_TYPE_GENERIC_LINE = 6,
  RoadMarking_Classification_Type_TYPE_GENERIC_TEXT = 7,
  RoadMarking_Classification_Type_RoadMarking_Classification_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RoadMarking_Classification_Type_RoadMarking_Classification_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RoadMarking_Classification_Type_IsValid(int value);
constexpr RoadMarking_Classification_Type RoadMarking_Classification_Type_Type_MIN = RoadMarking_Classification_Type_TYPE_UNKNOWN;
constexpr RoadMarking_Classification_Type RoadMarking_Classification_Type_Type_MAX = RoadMarking_Classification_Type_TYPE_GENERIC_TEXT;
constexpr int RoadMarking_Classification_Type_Type_ARRAYSIZE = RoadMarking_Classification_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RoadMarking_Classification_Type_descriptor();
template<typename T>
inline const std::string& RoadMarking_Classification_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RoadMarking_Classification_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RoadMarking_Classification_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RoadMarking_Classification_Type_descriptor(), enum_t_value);
}
inline bool RoadMarking_Classification_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RoadMarking_Classification_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RoadMarking_Classification_Type>(
    RoadMarking_Classification_Type_descriptor(), name, value);
}
enum RoadMarking_Classification_Color : int {
  RoadMarking_Classification_Color_COLOR_UNKNOWN = 0,
  RoadMarking_Classification_Color_COLOR_OTHER = 1,
  RoadMarking_Classification_Color_COLOR_WHITE = 2,
  RoadMarking_Classification_Color_COLOR_YELLOW = 3,
  RoadMarking_Classification_Color_COLOR_BLUE = 5,
  RoadMarking_Classification_Color_COLOR_RED = 6,
  RoadMarking_Classification_Color_COLOR_GREEN = 7,
  RoadMarking_Classification_Color_COLOR_VIOLET = 8,
  RoadMarking_Classification_Color_RoadMarking_Classification_Color_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RoadMarking_Classification_Color_RoadMarking_Classification_Color_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RoadMarking_Classification_Color_IsValid(int value);
constexpr RoadMarking_Classification_Color RoadMarking_Classification_Color_Color_MIN = RoadMarking_Classification_Color_COLOR_UNKNOWN;
constexpr RoadMarking_Classification_Color RoadMarking_Classification_Color_Color_MAX = RoadMarking_Classification_Color_COLOR_VIOLET;
constexpr int RoadMarking_Classification_Color_Color_ARRAYSIZE = RoadMarking_Classification_Color_Color_MAX + 1;

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

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

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

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

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

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

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

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

  public:

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

  typedef RoadMarking_Classification_Type Type;
  static constexpr Type TYPE_UNKNOWN =
    RoadMarking_Classification_Type_TYPE_UNKNOWN;
  static constexpr Type TYPE_OTHER =
    RoadMarking_Classification_Type_TYPE_OTHER;
  static constexpr Type TYPE_PAINTED_TRAFFIC_SIGN =
    RoadMarking_Classification_Type_TYPE_PAINTED_TRAFFIC_SIGN;
  static constexpr Type TYPE_SYMBOLIC_TRAFFIC_SIGN =
    RoadMarking_Classification_Type_TYPE_SYMBOLIC_TRAFFIC_SIGN;
  static constexpr Type TYPE_TEXTUAL_TRAFFIC_SIGN =
    RoadMarking_Classification_Type_TYPE_TEXTUAL_TRAFFIC_SIGN;
  static constexpr Type TYPE_GENERIC_SYMBOL =
    RoadMarking_Classification_Type_TYPE_GENERIC_SYMBOL;
  static constexpr Type TYPE_GENERIC_LINE =
    RoadMarking_Classification_Type_TYPE_GENERIC_LINE;
  static constexpr Type TYPE_GENERIC_TEXT =
    RoadMarking_Classification_Type_TYPE_GENERIC_TEXT;
  static inline bool Type_IsValid(int value) {
    return RoadMarking_Classification_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    RoadMarking_Classification_Type_Type_MIN;
  static constexpr Type Type_MAX =
    RoadMarking_Classification_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    RoadMarking_Classification_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return RoadMarking_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 RoadMarking_Classification_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return RoadMarking_Classification_Type_Parse(name, value);
  }

  typedef RoadMarking_Classification_Color Color;
  static constexpr Color COLOR_UNKNOWN =
    RoadMarking_Classification_Color_COLOR_UNKNOWN;
  static constexpr Color COLOR_OTHER =
    RoadMarking_Classification_Color_COLOR_OTHER;
  static constexpr Color COLOR_WHITE =
    RoadMarking_Classification_Color_COLOR_WHITE;
  static constexpr Color COLOR_YELLOW =
    RoadMarking_Classification_Color_COLOR_YELLOW;
  static constexpr Color COLOR_BLUE =
    RoadMarking_Classification_Color_COLOR_BLUE;
  static constexpr Color COLOR_RED =
    RoadMarking_Classification_Color_COLOR_RED;
  static constexpr Color COLOR_GREEN =
    RoadMarking_Classification_Color_COLOR_GREEN;
  static constexpr Color COLOR_VIOLET =
    RoadMarking_Classification_Color_COLOR_VIOLET;
  static inline bool Color_IsValid(int value) {
    return RoadMarking_Classification_Color_IsValid(value);
  }
  static constexpr Color Color_MIN =
    RoadMarking_Classification_Color_Color_MIN;
  static constexpr Color Color_MAX =
    RoadMarking_Classification_Color_Color_MAX;
  static constexpr int Color_ARRAYSIZE =
    RoadMarking_Classification_Color_Color_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Color_descriptor() {
    return RoadMarking_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 RoadMarking_Classification_Color_Name(enum_t_value);
  }
  static inline bool Color_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Color* value) {
    return RoadMarking_Classification_Color_Parse(name, value);
  }

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

  enum : int {
    kAssignedLaneIdFieldNumber = 6,
    kValueTextFieldNumber = 5,
    kValueFieldNumber = 4,
    kTypeFieldNumber = 1,
    kTrafficMainSignTypeFieldNumber = 2,
    kMonochromeColorFieldNumber = 3,
    kIsOutOfServiceFieldNumber = 7,
  };
  // repeated .osi3.Identifier assigned_lane_id = 6;
  int assigned_lane_id_size() const;
  private:
  int _internal_assigned_lane_id_size() const;
  public:
  void clear_assigned_lane_id();
  ::osi3::Identifier* mutable_assigned_lane_id(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
      mutable_assigned_lane_id();
  private:
  const ::osi3::Identifier& _internal_assigned_lane_id(int index) const;
  ::osi3::Identifier* _internal_add_assigned_lane_id();
  public:
  const ::osi3::Identifier& assigned_lane_id(int index) const;
  ::osi3::Identifier* add_assigned_lane_id();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
      assigned_lane_id() const;

  // string value_text = 5;
  void clear_value_text();
  const std::string& value_text() const;
  void set_value_text(const std::string& value);
  void set_value_text(std::string&& value);
  void set_value_text(const char* value);
  void set_value_text(const char* value, size_t size);
  std::string* mutable_value_text();
  std::string* release_value_text();
  void set_allocated_value_text(std::string* value_text);
  private:
  const std::string& _internal_value_text() const;
  void _internal_set_value_text(const std::string& value);
  std::string* _internal_mutable_value_text();
  public:

  // .osi3.TrafficSignValue value = 4;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::osi3::TrafficSignValue& value() const;
  ::osi3::TrafficSignValue* release_value();
  ::osi3::TrafficSignValue* mutable_value();
  void set_allocated_value(::osi3::TrafficSignValue* value);
  private:
  const ::osi3::TrafficSignValue& _internal_value() const;
  ::osi3::TrafficSignValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::osi3::TrafficSignValue* value);
  ::osi3::TrafficSignValue* unsafe_arena_release_value();

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

  // .osi3.TrafficSign.MainSign.Classification.Type traffic_main_sign_type = 2;
  void clear_traffic_main_sign_type();
  ::osi3::TrafficSign_MainSign_Classification_Type traffic_main_sign_type() const;
  void set_traffic_main_sign_type(::osi3::TrafficSign_MainSign_Classification_Type value);
  private:
  ::osi3::TrafficSign_MainSign_Classification_Type _internal_traffic_main_sign_type() const;
  void _internal_set_traffic_main_sign_type(::osi3::TrafficSign_MainSign_Classification_Type value);
  public:

  // .osi3.RoadMarking.Classification.Color monochrome_color = 3;
  void clear_monochrome_color();
  ::osi3::RoadMarking_Classification_Color monochrome_color() const;
  void set_monochrome_color(::osi3::RoadMarking_Classification_Color value);
  private:
  ::osi3::RoadMarking_Classification_Color _internal_monochrome_color() const;
  void _internal_set_monochrome_color(::osi3::RoadMarking_Classification_Color value);
  public:

  // bool is_out_of_service = 7;
  void clear_is_out_of_service();
  bool is_out_of_service() const;
  void set_is_out_of_service(bool value);
  private:
  bool _internal_is_out_of_service() const;
  void _internal_set_is_out_of_service(bool value);
  public:

  // @@protoc_insertion_point(class_scope:osi3.RoadMarking.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 > assigned_lane_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_text_;
  ::osi3::TrafficSignValue* value_;
  int type_;
  int traffic_main_sign_type_;
  int monochrome_color_;
  bool is_out_of_service_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5froadmarking_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

  typedef RoadMarking_Classification Classification;

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

  enum : int {
    kIdFieldNumber = 1,
    kBaseFieldNumber = 2,
    kClassificationFieldNumber = 3,
  };
  // .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.BaseStationary base = 2;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::osi3::BaseStationary& base() const;
  ::osi3::BaseStationary* release_base();
  ::osi3::BaseStationary* mutable_base();
  void set_allocated_base(::osi3::BaseStationary* base);
  private:
  const ::osi3::BaseStationary& _internal_base() const;
  ::osi3::BaseStationary* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::osi3::BaseStationary* base);
  ::osi3::BaseStationary* unsafe_arena_release_base();

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::osi3::Identifier* id_;
  ::osi3::BaseStationary* base_;
  ::osi3::RoadMarking_Classification* classification_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5froadmarking_2eproto;
};
// ===================================================================


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

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

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

// .osi3.TrafficSign.MainSign.Classification.Type traffic_main_sign_type = 2;
inline void RoadMarking_Classification::clear_traffic_main_sign_type() {
  traffic_main_sign_type_ = 0;
}
inline ::osi3::TrafficSign_MainSign_Classification_Type RoadMarking_Classification::_internal_traffic_main_sign_type() const {
  return static_cast< ::osi3::TrafficSign_MainSign_Classification_Type >(traffic_main_sign_type_);
}
inline ::osi3::TrafficSign_MainSign_Classification_Type RoadMarking_Classification::traffic_main_sign_type() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.traffic_main_sign_type)
  return _internal_traffic_main_sign_type();
}
inline void RoadMarking_Classification::_internal_set_traffic_main_sign_type(::osi3::TrafficSign_MainSign_Classification_Type value) {
  
  traffic_main_sign_type_ = value;
}
inline void RoadMarking_Classification::set_traffic_main_sign_type(::osi3::TrafficSign_MainSign_Classification_Type value) {
  _internal_set_traffic_main_sign_type(value);
  // @@protoc_insertion_point(field_set:osi3.RoadMarking.Classification.traffic_main_sign_type)
}

// .osi3.RoadMarking.Classification.Color monochrome_color = 3;
inline void RoadMarking_Classification::clear_monochrome_color() {
  monochrome_color_ = 0;
}
inline ::osi3::RoadMarking_Classification_Color RoadMarking_Classification::_internal_monochrome_color() const {
  return static_cast< ::osi3::RoadMarking_Classification_Color >(monochrome_color_);
}
inline ::osi3::RoadMarking_Classification_Color RoadMarking_Classification::monochrome_color() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.monochrome_color)
  return _internal_monochrome_color();
}
inline void RoadMarking_Classification::_internal_set_monochrome_color(::osi3::RoadMarking_Classification_Color value) {
  
  monochrome_color_ = value;
}
inline void RoadMarking_Classification::set_monochrome_color(::osi3::RoadMarking_Classification_Color value) {
  _internal_set_monochrome_color(value);
  // @@protoc_insertion_point(field_set:osi3.RoadMarking.Classification.monochrome_color)
}

// .osi3.TrafficSignValue value = 4;
inline bool RoadMarking_Classification::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool RoadMarking_Classification::has_value() const {
  return _internal_has_value();
}
inline const ::osi3::TrafficSignValue& RoadMarking_Classification::_internal_value() const {
  const ::osi3::TrafficSignValue* p = value_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::TrafficSignValue&>(
      ::osi3::_TrafficSignValue_default_instance_);
}
inline const ::osi3::TrafficSignValue& RoadMarking_Classification::value() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.value)
  return _internal_value();
}
inline void RoadMarking_Classification::unsafe_arena_set_allocated_value(
    ::osi3::TrafficSignValue* value) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  value_ = value;
  if (value) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.RoadMarking.Classification.value)
}
inline ::osi3::TrafficSignValue* RoadMarking_Classification::release_value() {
  
  ::osi3::TrafficSignValue* temp = value_;
  value_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::TrafficSignValue* RoadMarking_Classification::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:osi3.RoadMarking.Classification.value)
  
  ::osi3::TrafficSignValue* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::osi3::TrafficSignValue* RoadMarking_Classification::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::TrafficSignValue>(GetArena());
    value_ = p;
  }
  return value_;
}
inline ::osi3::TrafficSignValue* RoadMarking_Classification::mutable_value() {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.Classification.value)
  return _internal_mutable_value();
}
inline void RoadMarking_Classification::set_allocated_value(::osi3::TrafficSignValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:osi3.RoadMarking.Classification.value)
}

// string value_text = 5;
inline void RoadMarking_Classification::clear_value_text() {
  value_text_.ClearToEmpty();
}
inline const std::string& RoadMarking_Classification::value_text() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.value_text)
  return _internal_value_text();
}
inline void RoadMarking_Classification::set_value_text(const std::string& value) {
  _internal_set_value_text(value);
  // @@protoc_insertion_point(field_set:osi3.RoadMarking.Classification.value_text)
}
inline std::string* RoadMarking_Classification::mutable_value_text() {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.Classification.value_text)
  return _internal_mutable_value_text();
}
inline const std::string& RoadMarking_Classification::_internal_value_text() const {
  return value_text_.Get();
}
inline void RoadMarking_Classification::_internal_set_value_text(const std::string& value) {
  
  value_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void RoadMarking_Classification::set_value_text(std::string&& value) {
  
  value_text_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:osi3.RoadMarking.Classification.value_text)
}
inline void RoadMarking_Classification::set_value_text(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  value_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:osi3.RoadMarking.Classification.value_text)
}
inline void RoadMarking_Classification::set_value_text(const char* value,
    size_t size) {
  
  value_text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:osi3.RoadMarking.Classification.value_text)
}
inline std::string* RoadMarking_Classification::_internal_mutable_value_text() {
  
  return value_text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* RoadMarking_Classification::release_value_text() {
  // @@protoc_insertion_point(field_release:osi3.RoadMarking.Classification.value_text)
  return value_text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void RoadMarking_Classification::set_allocated_value_text(std::string* value_text) {
  if (value_text != nullptr) {
    
  } else {
    
  }
  value_text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value_text,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:osi3.RoadMarking.Classification.value_text)
}

// repeated .osi3.Identifier assigned_lane_id = 6;
inline int RoadMarking_Classification::_internal_assigned_lane_id_size() const {
  return assigned_lane_id_.size();
}
inline int RoadMarking_Classification::assigned_lane_id_size() const {
  return _internal_assigned_lane_id_size();
}
inline ::osi3::Identifier* RoadMarking_Classification::mutable_assigned_lane_id(int index) {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.Classification.assigned_lane_id)
  return assigned_lane_id_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >*
RoadMarking_Classification::mutable_assigned_lane_id() {
  // @@protoc_insertion_point(field_mutable_list:osi3.RoadMarking.Classification.assigned_lane_id)
  return &assigned_lane_id_;
}
inline const ::osi3::Identifier& RoadMarking_Classification::_internal_assigned_lane_id(int index) const {
  return assigned_lane_id_.Get(index);
}
inline const ::osi3::Identifier& RoadMarking_Classification::assigned_lane_id(int index) const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.assigned_lane_id)
  return _internal_assigned_lane_id(index);
}
inline ::osi3::Identifier* RoadMarking_Classification::_internal_add_assigned_lane_id() {
  return assigned_lane_id_.Add();
}
inline ::osi3::Identifier* RoadMarking_Classification::add_assigned_lane_id() {
  // @@protoc_insertion_point(field_add:osi3.RoadMarking.Classification.assigned_lane_id)
  return _internal_add_assigned_lane_id();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::osi3::Identifier >&
RoadMarking_Classification::assigned_lane_id() const {
  // @@protoc_insertion_point(field_list:osi3.RoadMarking.Classification.assigned_lane_id)
  return assigned_lane_id_;
}

// bool is_out_of_service = 7;
inline void RoadMarking_Classification::clear_is_out_of_service() {
  is_out_of_service_ = false;
}
inline bool RoadMarking_Classification::_internal_is_out_of_service() const {
  return is_out_of_service_;
}
inline bool RoadMarking_Classification::is_out_of_service() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.Classification.is_out_of_service)
  return _internal_is_out_of_service();
}
inline void RoadMarking_Classification::_internal_set_is_out_of_service(bool value) {
  
  is_out_of_service_ = value;
}
inline void RoadMarking_Classification::set_is_out_of_service(bool value) {
  _internal_set_is_out_of_service(value);
  // @@protoc_insertion_point(field_set:osi3.RoadMarking.Classification.is_out_of_service)
}

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

// RoadMarking

// .osi3.Identifier id = 1;
inline bool RoadMarking::_internal_has_id() const {
  return this != internal_default_instance() && id_ != nullptr;
}
inline bool RoadMarking::has_id() const {
  return _internal_has_id();
}
inline const ::osi3::Identifier& RoadMarking::_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& RoadMarking::id() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.id)
  return _internal_id();
}
inline void RoadMarking::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.RoadMarking.id)
}
inline ::osi3::Identifier* RoadMarking::release_id() {
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::Identifier* RoadMarking::unsafe_arena_release_id() {
  // @@protoc_insertion_point(field_release:osi3.RoadMarking.id)
  
  ::osi3::Identifier* temp = id_;
  id_ = nullptr;
  return temp;
}
inline ::osi3::Identifier* RoadMarking::_internal_mutable_id() {
  
  if (id_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::Identifier>(GetArena());
    id_ = p;
  }
  return id_;
}
inline ::osi3::Identifier* RoadMarking::mutable_id() {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.id)
  return _internal_mutable_id();
}
inline void RoadMarking::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.RoadMarking.id)
}

// .osi3.BaseStationary base = 2;
inline bool RoadMarking::_internal_has_base() const {
  return this != internal_default_instance() && base_ != nullptr;
}
inline bool RoadMarking::has_base() const {
  return _internal_has_base();
}
inline const ::osi3::BaseStationary& RoadMarking::_internal_base() const {
  const ::osi3::BaseStationary* p = base_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::BaseStationary&>(
      ::osi3::_BaseStationary_default_instance_);
}
inline const ::osi3::BaseStationary& RoadMarking::base() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.base)
  return _internal_base();
}
inline void RoadMarking::unsafe_arena_set_allocated_base(
    ::osi3::BaseStationary* base) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_);
  }
  base_ = base;
  if (base) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:osi3.RoadMarking.base)
}
inline ::osi3::BaseStationary* RoadMarking::release_base() {
  
  ::osi3::BaseStationary* temp = base_;
  base_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::BaseStationary* RoadMarking::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:osi3.RoadMarking.base)
  
  ::osi3::BaseStationary* temp = base_;
  base_ = nullptr;
  return temp;
}
inline ::osi3::BaseStationary* RoadMarking::_internal_mutable_base() {
  
  if (base_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::BaseStationary>(GetArena());
    base_ = p;
  }
  return base_;
}
inline ::osi3::BaseStationary* RoadMarking::mutable_base() {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.base)
  return _internal_mutable_base();
}
inline void RoadMarking::set_allocated_base(::osi3::BaseStationary* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_);
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base)->GetArena();
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    
  } else {
    
  }
  base_ = base;
  // @@protoc_insertion_point(field_set_allocated:osi3.RoadMarking.base)
}

// .osi3.RoadMarking.Classification classification = 3;
inline bool RoadMarking::_internal_has_classification() const {
  return this != internal_default_instance() && classification_ != nullptr;
}
inline bool RoadMarking::has_classification() const {
  return _internal_has_classification();
}
inline void RoadMarking::clear_classification() {
  if (GetArena() == nullptr && classification_ != nullptr) {
    delete classification_;
  }
  classification_ = nullptr;
}
inline const ::osi3::RoadMarking_Classification& RoadMarking::_internal_classification() const {
  const ::osi3::RoadMarking_Classification* p = classification_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::RoadMarking_Classification&>(
      ::osi3::_RoadMarking_Classification_default_instance_);
}
inline const ::osi3::RoadMarking_Classification& RoadMarking::classification() const {
  // @@protoc_insertion_point(field_get:osi3.RoadMarking.classification)
  return _internal_classification();
}
inline void RoadMarking::unsafe_arena_set_allocated_classification(
    ::osi3::RoadMarking_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.RoadMarking.classification)
}
inline ::osi3::RoadMarking_Classification* RoadMarking::release_classification() {
  
  ::osi3::RoadMarking_Classification* temp = classification_;
  classification_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::RoadMarking_Classification* RoadMarking::unsafe_arena_release_classification() {
  // @@protoc_insertion_point(field_release:osi3.RoadMarking.classification)
  
  ::osi3::RoadMarking_Classification* temp = classification_;
  classification_ = nullptr;
  return temp;
}
inline ::osi3::RoadMarking_Classification* RoadMarking::_internal_mutable_classification() {
  
  if (classification_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::RoadMarking_Classification>(GetArena());
    classification_ = p;
  }
  return classification_;
}
inline ::osi3::RoadMarking_Classification* RoadMarking::mutable_classification() {
  // @@protoc_insertion_point(field_mutable:osi3.RoadMarking.classification)
  return _internal_mutable_classification();
}
inline void RoadMarking::set_allocated_classification(::osi3::RoadMarking_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.RoadMarking.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::RoadMarking_Classification_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::RoadMarking_Classification_Type>() {
  return ::osi3::RoadMarking_Classification_Type_descriptor();
}
template <> struct is_proto_enum< ::osi3::RoadMarking_Classification_Color> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::RoadMarking_Classification_Color>() {
  return ::osi3::RoadMarking_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_5froadmarking_2eproto
