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

#ifndef GOOGLE_PROTOBUF_INCLUDED_osi_5ftrafficlight_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_osi_5ftrafficlight_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_5ftrafficlight_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_osi_5ftrafficlight_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_5ftrafficlight_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_osi_5ftrafficlight_2eproto_metadata_getter(int index);
namespace osi3 {
class TrafficLight;
struct TrafficLightDefaultTypeInternal;
extern TrafficLightDefaultTypeInternal _TrafficLight_default_instance_;
class TrafficLight_Classification;
struct TrafficLight_ClassificationDefaultTypeInternal;
extern TrafficLight_ClassificationDefaultTypeInternal _TrafficLight_Classification_default_instance_;
}  // namespace osi3
PROTOBUF_NAMESPACE_OPEN
template<> ::osi3::TrafficLight* Arena::CreateMaybeMessage<::osi3::TrafficLight>(Arena*);
template<> ::osi3::TrafficLight_Classification* Arena::CreateMaybeMessage<::osi3::TrafficLight_Classification>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace osi3 {

enum TrafficLight_Classification_Color : int {
  TrafficLight_Classification_Color_COLOR_UNKNOWN = 0,
  TrafficLight_Classification_Color_COLOR_OTHER = 1,
  TrafficLight_Classification_Color_COLOR_RED = 2,
  TrafficLight_Classification_Color_COLOR_YELLOW = 3,
  TrafficLight_Classification_Color_COLOR_GREEN = 4,
  TrafficLight_Classification_Color_COLOR_BLUE = 5,
  TrafficLight_Classification_Color_COLOR_WHITE = 6,
  TrafficLight_Classification_Color_TrafficLight_Classification_Color_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TrafficLight_Classification_Color_TrafficLight_Classification_Color_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TrafficLight_Classification_Color_IsValid(int value);
constexpr TrafficLight_Classification_Color TrafficLight_Classification_Color_Color_MIN = TrafficLight_Classification_Color_COLOR_UNKNOWN;
constexpr TrafficLight_Classification_Color TrafficLight_Classification_Color_Color_MAX = TrafficLight_Classification_Color_COLOR_WHITE;
constexpr int TrafficLight_Classification_Color_Color_ARRAYSIZE = TrafficLight_Classification_Color_Color_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrafficLight_Classification_Color_descriptor();
template<typename T>
inline const std::string& TrafficLight_Classification_Color_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TrafficLight_Classification_Color>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TrafficLight_Classification_Color_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TrafficLight_Classification_Color_descriptor(), enum_t_value);
}
inline bool TrafficLight_Classification_Color_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TrafficLight_Classification_Color* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TrafficLight_Classification_Color>(
    TrafficLight_Classification_Color_descriptor(), name, value);
}
enum TrafficLight_Classification_Icon : int {
  TrafficLight_Classification_Icon_ICON_UNKNOWN = 0,
  TrafficLight_Classification_Icon_ICON_OTHER = 1,
  TrafficLight_Classification_Icon_ICON_NONE = 2,
  TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD = 3,
  TrafficLight_Classification_Icon_ICON_ARROW_LEFT = 4,
  TrafficLight_Classification_Icon_ICON_ARROW_DIAG_LEFT = 5,
  TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD_LEFT = 6,
  TrafficLight_Classification_Icon_ICON_ARROW_RIGHT = 7,
  TrafficLight_Classification_Icon_ICON_ARROW_DIAG_RIGHT = 8,
  TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD_RIGHT = 9,
  TrafficLight_Classification_Icon_ICON_ARROW_LEFT_RIGHT = 10,
  TrafficLight_Classification_Icon_ICON_ARROW_DOWN = 11,
  TrafficLight_Classification_Icon_ICON_ARROW_DOWN_LEFT = 12,
  TrafficLight_Classification_Icon_ICON_ARROW_DOWN_RIGHT = 13,
  TrafficLight_Classification_Icon_ICON_ARROW_CROSS = 14,
  TrafficLight_Classification_Icon_ICON_PEDESTRIAN = 15,
  TrafficLight_Classification_Icon_ICON_WALK = 16,
  TrafficLight_Classification_Icon_ICON_DONT_WALK = 17,
  TrafficLight_Classification_Icon_ICON_BICYCLE = 18,
  TrafficLight_Classification_Icon_ICON_PEDESTRIAN_AND_BICYCLE = 19,
  TrafficLight_Classification_Icon_ICON_COUNTDOWN_SECONDS = 20,
  TrafficLight_Classification_Icon_ICON_COUNTDOWN_PERCENT = 21,
  TrafficLight_Classification_Icon_ICON_TRAM = 22,
  TrafficLight_Classification_Icon_ICON_BUS = 23,
  TrafficLight_Classification_Icon_ICON_BUS_AND_TRAM = 24,
  TrafficLight_Classification_Icon_TrafficLight_Classification_Icon_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TrafficLight_Classification_Icon_TrafficLight_Classification_Icon_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TrafficLight_Classification_Icon_IsValid(int value);
constexpr TrafficLight_Classification_Icon TrafficLight_Classification_Icon_Icon_MIN = TrafficLight_Classification_Icon_ICON_UNKNOWN;
constexpr TrafficLight_Classification_Icon TrafficLight_Classification_Icon_Icon_MAX = TrafficLight_Classification_Icon_ICON_BUS_AND_TRAM;
constexpr int TrafficLight_Classification_Icon_Icon_ARRAYSIZE = TrafficLight_Classification_Icon_Icon_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TrafficLight_Classification_Icon_descriptor();
template<typename T>
inline const std::string& TrafficLight_Classification_Icon_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TrafficLight_Classification_Icon>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TrafficLight_Classification_Icon_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TrafficLight_Classification_Icon_descriptor(), enum_t_value);
}
inline bool TrafficLight_Classification_Icon_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TrafficLight_Classification_Icon* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TrafficLight_Classification_Icon>(
    TrafficLight_Classification_Icon_descriptor(), name, value);
}
enum TrafficLight_Classification_Mode : int {
  TrafficLight_Classification_Mode_MODE_UNKNOWN = 0,
  TrafficLight_Classification_Mode_MODE_OTHER = 1,
  TrafficLight_Classification_Mode_MODE_OFF = 2,
  TrafficLight_Classification_Mode_MODE_CONSTANT = 3,
  TrafficLight_Classification_Mode_MODE_FLASHING = 4,
  TrafficLight_Classification_Mode_MODE_COUNTING = 5,
  TrafficLight_Classification_Mode_TrafficLight_Classification_Mode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  TrafficLight_Classification_Mode_TrafficLight_Classification_Mode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool TrafficLight_Classification_Mode_IsValid(int value);
constexpr TrafficLight_Classification_Mode TrafficLight_Classification_Mode_Mode_MIN = TrafficLight_Classification_Mode_MODE_UNKNOWN;
constexpr TrafficLight_Classification_Mode TrafficLight_Classification_Mode_Mode_MAX = TrafficLight_Classification_Mode_MODE_COUNTING;
constexpr int TrafficLight_Classification_Mode_Mode_ARRAYSIZE = TrafficLight_Classification_Mode_Mode_MAX + 1;

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

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

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

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

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

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

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

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

  public:

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

  typedef TrafficLight_Classification_Color Color;
  static constexpr Color COLOR_UNKNOWN =
    TrafficLight_Classification_Color_COLOR_UNKNOWN;
  static constexpr Color COLOR_OTHER =
    TrafficLight_Classification_Color_COLOR_OTHER;
  static constexpr Color COLOR_RED =
    TrafficLight_Classification_Color_COLOR_RED;
  static constexpr Color COLOR_YELLOW =
    TrafficLight_Classification_Color_COLOR_YELLOW;
  static constexpr Color COLOR_GREEN =
    TrafficLight_Classification_Color_COLOR_GREEN;
  static constexpr Color COLOR_BLUE =
    TrafficLight_Classification_Color_COLOR_BLUE;
  static constexpr Color COLOR_WHITE =
    TrafficLight_Classification_Color_COLOR_WHITE;
  static inline bool Color_IsValid(int value) {
    return TrafficLight_Classification_Color_IsValid(value);
  }
  static constexpr Color Color_MIN =
    TrafficLight_Classification_Color_Color_MIN;
  static constexpr Color Color_MAX =
    TrafficLight_Classification_Color_Color_MAX;
  static constexpr int Color_ARRAYSIZE =
    TrafficLight_Classification_Color_Color_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Color_descriptor() {
    return TrafficLight_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 TrafficLight_Classification_Color_Name(enum_t_value);
  }
  static inline bool Color_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Color* value) {
    return TrafficLight_Classification_Color_Parse(name, value);
  }

  typedef TrafficLight_Classification_Icon Icon;
  static constexpr Icon ICON_UNKNOWN =
    TrafficLight_Classification_Icon_ICON_UNKNOWN;
  static constexpr Icon ICON_OTHER =
    TrafficLight_Classification_Icon_ICON_OTHER;
  static constexpr Icon ICON_NONE =
    TrafficLight_Classification_Icon_ICON_NONE;
  static constexpr Icon ICON_ARROW_STRAIGHT_AHEAD =
    TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD;
  static constexpr Icon ICON_ARROW_LEFT =
    TrafficLight_Classification_Icon_ICON_ARROW_LEFT;
  static constexpr Icon ICON_ARROW_DIAG_LEFT =
    TrafficLight_Classification_Icon_ICON_ARROW_DIAG_LEFT;
  static constexpr Icon ICON_ARROW_STRAIGHT_AHEAD_LEFT =
    TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD_LEFT;
  static constexpr Icon ICON_ARROW_RIGHT =
    TrafficLight_Classification_Icon_ICON_ARROW_RIGHT;
  static constexpr Icon ICON_ARROW_DIAG_RIGHT =
    TrafficLight_Classification_Icon_ICON_ARROW_DIAG_RIGHT;
  static constexpr Icon ICON_ARROW_STRAIGHT_AHEAD_RIGHT =
    TrafficLight_Classification_Icon_ICON_ARROW_STRAIGHT_AHEAD_RIGHT;
  static constexpr Icon ICON_ARROW_LEFT_RIGHT =
    TrafficLight_Classification_Icon_ICON_ARROW_LEFT_RIGHT;
  static constexpr Icon ICON_ARROW_DOWN =
    TrafficLight_Classification_Icon_ICON_ARROW_DOWN;
  static constexpr Icon ICON_ARROW_DOWN_LEFT =
    TrafficLight_Classification_Icon_ICON_ARROW_DOWN_LEFT;
  static constexpr Icon ICON_ARROW_DOWN_RIGHT =
    TrafficLight_Classification_Icon_ICON_ARROW_DOWN_RIGHT;
  static constexpr Icon ICON_ARROW_CROSS =
    TrafficLight_Classification_Icon_ICON_ARROW_CROSS;
  static constexpr Icon ICON_PEDESTRIAN =
    TrafficLight_Classification_Icon_ICON_PEDESTRIAN;
  static constexpr Icon ICON_WALK =
    TrafficLight_Classification_Icon_ICON_WALK;
  static constexpr Icon ICON_DONT_WALK =
    TrafficLight_Classification_Icon_ICON_DONT_WALK;
  static constexpr Icon ICON_BICYCLE =
    TrafficLight_Classification_Icon_ICON_BICYCLE;
  static constexpr Icon ICON_PEDESTRIAN_AND_BICYCLE =
    TrafficLight_Classification_Icon_ICON_PEDESTRIAN_AND_BICYCLE;
  static constexpr Icon ICON_COUNTDOWN_SECONDS =
    TrafficLight_Classification_Icon_ICON_COUNTDOWN_SECONDS;
  static constexpr Icon ICON_COUNTDOWN_PERCENT =
    TrafficLight_Classification_Icon_ICON_COUNTDOWN_PERCENT;
  static constexpr Icon ICON_TRAM =
    TrafficLight_Classification_Icon_ICON_TRAM;
  static constexpr Icon ICON_BUS =
    TrafficLight_Classification_Icon_ICON_BUS;
  static constexpr Icon ICON_BUS_AND_TRAM =
    TrafficLight_Classification_Icon_ICON_BUS_AND_TRAM;
  static inline bool Icon_IsValid(int value) {
    return TrafficLight_Classification_Icon_IsValid(value);
  }
  static constexpr Icon Icon_MIN =
    TrafficLight_Classification_Icon_Icon_MIN;
  static constexpr Icon Icon_MAX =
    TrafficLight_Classification_Icon_Icon_MAX;
  static constexpr int Icon_ARRAYSIZE =
    TrafficLight_Classification_Icon_Icon_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Icon_descriptor() {
    return TrafficLight_Classification_Icon_descriptor();
  }
  template<typename T>
  static inline const std::string& Icon_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Icon>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Icon_Name.");
    return TrafficLight_Classification_Icon_Name(enum_t_value);
  }
  static inline bool Icon_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Icon* value) {
    return TrafficLight_Classification_Icon_Parse(name, value);
  }

  typedef TrafficLight_Classification_Mode Mode;
  static constexpr Mode MODE_UNKNOWN =
    TrafficLight_Classification_Mode_MODE_UNKNOWN;
  static constexpr Mode MODE_OTHER =
    TrafficLight_Classification_Mode_MODE_OTHER;
  static constexpr Mode MODE_OFF =
    TrafficLight_Classification_Mode_MODE_OFF;
  static constexpr Mode MODE_CONSTANT =
    TrafficLight_Classification_Mode_MODE_CONSTANT;
  static constexpr Mode MODE_FLASHING =
    TrafficLight_Classification_Mode_MODE_FLASHING;
  static constexpr Mode MODE_COUNTING =
    TrafficLight_Classification_Mode_MODE_COUNTING;
  static inline bool Mode_IsValid(int value) {
    return TrafficLight_Classification_Mode_IsValid(value);
  }
  static constexpr Mode Mode_MIN =
    TrafficLight_Classification_Mode_Mode_MIN;
  static constexpr Mode Mode_MAX =
    TrafficLight_Classification_Mode_Mode_MAX;
  static constexpr int Mode_ARRAYSIZE =
    TrafficLight_Classification_Mode_Mode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Mode_descriptor() {
    return TrafficLight_Classification_Mode_descriptor();
  }
  template<typename T>
  static inline const std::string& Mode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Mode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Mode_Name.");
    return TrafficLight_Classification_Mode_Name(enum_t_value);
  }
  static inline bool Mode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Mode* value) {
    return TrafficLight_Classification_Mode_Parse(name, value);
  }

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

  enum : int {
    kAssignedLaneIdFieldNumber = 5,
    kColorFieldNumber = 1,
    kIconFieldNumber = 2,
    kCounterFieldNumber = 4,
    kModeFieldNumber = 3,
    kIsOutOfServiceFieldNumber = 6,
  };
  // repeated .osi3.Identifier assigned_lane_id = 5;
  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;

  // .osi3.TrafficLight.Classification.Color color = 1;
  void clear_color();
  ::osi3::TrafficLight_Classification_Color color() const;
  void set_color(::osi3::TrafficLight_Classification_Color value);
  private:
  ::osi3::TrafficLight_Classification_Color _internal_color() const;
  void _internal_set_color(::osi3::TrafficLight_Classification_Color value);
  public:

  // .osi3.TrafficLight.Classification.Icon icon = 2;
  void clear_icon();
  ::osi3::TrafficLight_Classification_Icon icon() const;
  void set_icon(::osi3::TrafficLight_Classification_Icon value);
  private:
  ::osi3::TrafficLight_Classification_Icon _internal_icon() const;
  void _internal_set_icon(::osi3::TrafficLight_Classification_Icon value);
  public:

  // double counter = 4;
  void clear_counter();
  double counter() const;
  void set_counter(double value);
  private:
  double _internal_counter() const;
  void _internal_set_counter(double value);
  public:

  // .osi3.TrafficLight.Classification.Mode mode = 3;
  void clear_mode();
  ::osi3::TrafficLight_Classification_Mode mode() const;
  void set_mode(::osi3::TrafficLight_Classification_Mode value);
  private:
  ::osi3::TrafficLight_Classification_Mode _internal_mode() const;
  void _internal_set_mode(::osi3::TrafficLight_Classification_Mode value);
  public:

  // bool is_out_of_service = 6;
  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.TrafficLight.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_;
  int color_;
  int icon_;
  double counter_;
  int mode_;
  bool is_out_of_service_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_osi_5ftrafficlight_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  public:

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

  typedef TrafficLight_Classification Classification;

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

  enum : int {
    kModelReferenceFieldNumber = 4,
    kIdFieldNumber = 1,
    kBaseFieldNumber = 2,
    kClassificationFieldNumber = 3,
  };
  // string model_reference = 4;
  void clear_model_reference();
  const std::string& model_reference() const;
  void set_model_reference(const std::string& value);
  void set_model_reference(std::string&& value);
  void set_model_reference(const char* value);
  void set_model_reference(const char* value, size_t size);
  std::string* mutable_model_reference();
  std::string* release_model_reference();
  void set_allocated_model_reference(std::string* model_reference);
  private:
  const std::string& _internal_model_reference() const;
  void _internal_set_model_reference(const std::string& value);
  std::string* _internal_mutable_model_reference();
  public:

  // .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.TrafficLight.Classification classification = 3;
  bool has_classification() const;
  private:
  bool _internal_has_classification() const;
  public:
  void clear_classification();
  const ::osi3::TrafficLight_Classification& classification() const;
  ::osi3::TrafficLight_Classification* release_classification();
  ::osi3::TrafficLight_Classification* mutable_classification();
  void set_allocated_classification(::osi3::TrafficLight_Classification* classification);
  private:
  const ::osi3::TrafficLight_Classification& _internal_classification() const;
  ::osi3::TrafficLight_Classification* _internal_mutable_classification();
  public:
  void unsafe_arena_set_allocated_classification(
      ::osi3::TrafficLight_Classification* classification);
  ::osi3::TrafficLight_Classification* unsafe_arena_release_classification();

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

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


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

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

// .osi3.TrafficLight.Classification.Color color = 1;
inline void TrafficLight_Classification::clear_color() {
  color_ = 0;
}
inline ::osi3::TrafficLight_Classification_Color TrafficLight_Classification::_internal_color() const {
  return static_cast< ::osi3::TrafficLight_Classification_Color >(color_);
}
inline ::osi3::TrafficLight_Classification_Color TrafficLight_Classification::color() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.Classification.color)
  return _internal_color();
}
inline void TrafficLight_Classification::_internal_set_color(::osi3::TrafficLight_Classification_Color value) {
  
  color_ = value;
}
inline void TrafficLight_Classification::set_color(::osi3::TrafficLight_Classification_Color value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:osi3.TrafficLight.Classification.color)
}

// .osi3.TrafficLight.Classification.Icon icon = 2;
inline void TrafficLight_Classification::clear_icon() {
  icon_ = 0;
}
inline ::osi3::TrafficLight_Classification_Icon TrafficLight_Classification::_internal_icon() const {
  return static_cast< ::osi3::TrafficLight_Classification_Icon >(icon_);
}
inline ::osi3::TrafficLight_Classification_Icon TrafficLight_Classification::icon() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.Classification.icon)
  return _internal_icon();
}
inline void TrafficLight_Classification::_internal_set_icon(::osi3::TrafficLight_Classification_Icon value) {
  
  icon_ = value;
}
inline void TrafficLight_Classification::set_icon(::osi3::TrafficLight_Classification_Icon value) {
  _internal_set_icon(value);
  // @@protoc_insertion_point(field_set:osi3.TrafficLight.Classification.icon)
}

// .osi3.TrafficLight.Classification.Mode mode = 3;
inline void TrafficLight_Classification::clear_mode() {
  mode_ = 0;
}
inline ::osi3::TrafficLight_Classification_Mode TrafficLight_Classification::_internal_mode() const {
  return static_cast< ::osi3::TrafficLight_Classification_Mode >(mode_);
}
inline ::osi3::TrafficLight_Classification_Mode TrafficLight_Classification::mode() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.Classification.mode)
  return _internal_mode();
}
inline void TrafficLight_Classification::_internal_set_mode(::osi3::TrafficLight_Classification_Mode value) {
  
  mode_ = value;
}
inline void TrafficLight_Classification::set_mode(::osi3::TrafficLight_Classification_Mode value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:osi3.TrafficLight.Classification.mode)
}

// double counter = 4;
inline void TrafficLight_Classification::clear_counter() {
  counter_ = 0;
}
inline double TrafficLight_Classification::_internal_counter() const {
  return counter_;
}
inline double TrafficLight_Classification::counter() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.Classification.counter)
  return _internal_counter();
}
inline void TrafficLight_Classification::_internal_set_counter(double value) {
  
  counter_ = value;
}
inline void TrafficLight_Classification::set_counter(double value) {
  _internal_set_counter(value);
  // @@protoc_insertion_point(field_set:osi3.TrafficLight.Classification.counter)
}

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

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

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

// TrafficLight

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

// .osi3.BaseStationary base = 2;
inline bool TrafficLight::_internal_has_base() const {
  return this != internal_default_instance() && base_ != nullptr;
}
inline bool TrafficLight::has_base() const {
  return _internal_has_base();
}
inline const ::osi3::BaseStationary& TrafficLight::_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& TrafficLight::base() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.base)
  return _internal_base();
}
inline void TrafficLight::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.TrafficLight.base)
}
inline ::osi3::BaseStationary* TrafficLight::release_base() {
  
  ::osi3::BaseStationary* temp = base_;
  base_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::BaseStationary* TrafficLight::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:osi3.TrafficLight.base)
  
  ::osi3::BaseStationary* temp = base_;
  base_ = nullptr;
  return temp;
}
inline ::osi3::BaseStationary* TrafficLight::_internal_mutable_base() {
  
  if (base_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::BaseStationary>(GetArena());
    base_ = p;
  }
  return base_;
}
inline ::osi3::BaseStationary* TrafficLight::mutable_base() {
  // @@protoc_insertion_point(field_mutable:osi3.TrafficLight.base)
  return _internal_mutable_base();
}
inline void TrafficLight::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.TrafficLight.base)
}

// .osi3.TrafficLight.Classification classification = 3;
inline bool TrafficLight::_internal_has_classification() const {
  return this != internal_default_instance() && classification_ != nullptr;
}
inline bool TrafficLight::has_classification() const {
  return _internal_has_classification();
}
inline void TrafficLight::clear_classification() {
  if (GetArena() == nullptr && classification_ != nullptr) {
    delete classification_;
  }
  classification_ = nullptr;
}
inline const ::osi3::TrafficLight_Classification& TrafficLight::_internal_classification() const {
  const ::osi3::TrafficLight_Classification* p = classification_;
  return p != nullptr ? *p : reinterpret_cast<const ::osi3::TrafficLight_Classification&>(
      ::osi3::_TrafficLight_Classification_default_instance_);
}
inline const ::osi3::TrafficLight_Classification& TrafficLight::classification() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.classification)
  return _internal_classification();
}
inline void TrafficLight::unsafe_arena_set_allocated_classification(
    ::osi3::TrafficLight_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.TrafficLight.classification)
}
inline ::osi3::TrafficLight_Classification* TrafficLight::release_classification() {
  
  ::osi3::TrafficLight_Classification* temp = classification_;
  classification_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::osi3::TrafficLight_Classification* TrafficLight::unsafe_arena_release_classification() {
  // @@protoc_insertion_point(field_release:osi3.TrafficLight.classification)
  
  ::osi3::TrafficLight_Classification* temp = classification_;
  classification_ = nullptr;
  return temp;
}
inline ::osi3::TrafficLight_Classification* TrafficLight::_internal_mutable_classification() {
  
  if (classification_ == nullptr) {
    auto* p = CreateMaybeMessage<::osi3::TrafficLight_Classification>(GetArena());
    classification_ = p;
  }
  return classification_;
}
inline ::osi3::TrafficLight_Classification* TrafficLight::mutable_classification() {
  // @@protoc_insertion_point(field_mutable:osi3.TrafficLight.classification)
  return _internal_mutable_classification();
}
inline void TrafficLight::set_allocated_classification(::osi3::TrafficLight_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.TrafficLight.classification)
}

// string model_reference = 4;
inline void TrafficLight::clear_model_reference() {
  model_reference_.ClearToEmpty();
}
inline const std::string& TrafficLight::model_reference() const {
  // @@protoc_insertion_point(field_get:osi3.TrafficLight.model_reference)
  return _internal_model_reference();
}
inline void TrafficLight::set_model_reference(const std::string& value) {
  _internal_set_model_reference(value);
  // @@protoc_insertion_point(field_set:osi3.TrafficLight.model_reference)
}
inline std::string* TrafficLight::mutable_model_reference() {
  // @@protoc_insertion_point(field_mutable:osi3.TrafficLight.model_reference)
  return _internal_mutable_model_reference();
}
inline const std::string& TrafficLight::_internal_model_reference() const {
  return model_reference_.Get();
}
inline void TrafficLight::_internal_set_model_reference(const std::string& value) {
  
  model_reference_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void TrafficLight::set_model_reference(std::string&& value) {
  
  model_reference_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:osi3.TrafficLight.model_reference)
}
inline void TrafficLight::set_model_reference(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  model_reference_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:osi3.TrafficLight.model_reference)
}
inline void TrafficLight::set_model_reference(const char* value,
    size_t size) {
  
  model_reference_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:osi3.TrafficLight.model_reference)
}
inline std::string* TrafficLight::_internal_mutable_model_reference() {
  
  return model_reference_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* TrafficLight::release_model_reference() {
  // @@protoc_insertion_point(field_release:osi3.TrafficLight.model_reference)
  return model_reference_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void TrafficLight::set_allocated_model_reference(std::string* model_reference) {
  if (model_reference != nullptr) {
    
  } else {
    
  }
  model_reference_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_reference,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:osi3.TrafficLight.model_reference)
}

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace osi3

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::osi3::TrafficLight_Classification_Color> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::TrafficLight_Classification_Color>() {
  return ::osi3::TrafficLight_Classification_Color_descriptor();
}
template <> struct is_proto_enum< ::osi3::TrafficLight_Classification_Icon> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::TrafficLight_Classification_Icon>() {
  return ::osi3::TrafficLight_Classification_Icon_descriptor();
}
template <> struct is_proto_enum< ::osi3::TrafficLight_Classification_Mode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::osi3::TrafficLight_Classification_Mode>() {
  return ::osi3::TrafficLight_Classification_Mode_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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