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

#ifndef GOOGLE_PROTOBUF_INCLUDED_sdf_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_sdf_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021010 < 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_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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_sdf_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_sdf_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_sdf_2eproto;
namespace SDF {
class ADF_EventInfoSource;
struct ADF_EventInfoSourceDefaultTypeInternal;
extern ADF_EventInfoSourceDefaultTypeInternal _ADF_EventInfoSource_default_instance_;
class ADF_EventTimeInfo;
struct ADF_EventTimeInfoDefaultTypeInternal;
extern ADF_EventTimeInfoDefaultTypeInternal _ADF_EventTimeInfo_default_instance_;
class ADF_TrafficLightPhaseStage;
struct ADF_TrafficLightPhaseStageDefaultTypeInternal;
extern ADF_TrafficLightPhaseStageDefaultTypeInternal _ADF_TrafficLightPhaseStage_default_instance_;
class EDF_TrafficLightRealTimeInfo;
struct EDF_TrafficLightRealTimeInfoDefaultTypeInternal;
extern EDF_TrafficLightRealTimeInfoDefaultTypeInternal _EDF_TrafficLightRealTimeInfo_default_instance_;
class RequestSequence;
struct RequestSequenceDefaultTypeInternal;
extern RequestSequenceDefaultTypeInternal _RequestSequence_default_instance_;
class TrafficLightLayer;
struct TrafficLightLayerDefaultTypeInternal;
extern TrafficLightLayerDefaultTypeInternal _TrafficLightLayer_default_instance_;
class TrafficLightLayerResponse;
struct TrafficLightLayerResponseDefaultTypeInternal;
extern TrafficLightLayerResponseDefaultTypeInternal _TrafficLightLayerResponse_default_instance_;
}  // namespace SDF
PROTOBUF_NAMESPACE_OPEN
template<> ::SDF::ADF_EventInfoSource* Arena::CreateMaybeMessage<::SDF::ADF_EventInfoSource>(Arena*);
template<> ::SDF::ADF_EventTimeInfo* Arena::CreateMaybeMessage<::SDF::ADF_EventTimeInfo>(Arena*);
template<> ::SDF::ADF_TrafficLightPhaseStage* Arena::CreateMaybeMessage<::SDF::ADF_TrafficLightPhaseStage>(Arena*);
template<> ::SDF::EDF_TrafficLightRealTimeInfo* Arena::CreateMaybeMessage<::SDF::EDF_TrafficLightRealTimeInfo>(Arena*);
template<> ::SDF::RequestSequence* Arena::CreateMaybeMessage<::SDF::RequestSequence>(Arena*);
template<> ::SDF::TrafficLightLayer* Arena::CreateMaybeMessage<::SDF::TrafficLightLayer>(Arena*);
template<> ::SDF::TrafficLightLayerResponse* Arena::CreateMaybeMessage<::SDF::TrafficLightLayerResponse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace SDF {

enum ADF_TrafficLightPhaseStage_TrafficLightColorType : int {
  ADF_TrafficLightPhaseStage_TrafficLightColorType_UNKNOWN = 0,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_BLACK = 1,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_RED = 2,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_RED_FLASH = 3,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_YELLOW = 4,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_YELLOW_FLASH = 5,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_GREEN = 6,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_GREEN_FLASH = 7,
  ADF_TrafficLightPhaseStage_TrafficLightColorType_ADF_TrafficLightPhaseStage_TrafficLightColorType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ADF_TrafficLightPhaseStage_TrafficLightColorType_ADF_TrafficLightPhaseStage_TrafficLightColorType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ADF_TrafficLightPhaseStage_TrafficLightColorType_IsValid(int value);
constexpr ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_MIN = ADF_TrafficLightPhaseStage_TrafficLightColorType_UNKNOWN;
constexpr ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_MAX = ADF_TrafficLightPhaseStage_TrafficLightColorType_GREEN_FLASH;
constexpr int ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_ARRAYSIZE = ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_MAX + 1;

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

class ADF_EventTimeInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.ADF_EventTimeInfo) */ {
 public:
  inline ADF_EventTimeInfo() : ADF_EventTimeInfo(nullptr) {}
  ~ADF_EventTimeInfo() override;
  explicit PROTOBUF_CONSTEXPR ADF_EventTimeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ADF_EventTimeInfo& operator=(const ADF_EventTimeInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ADF_EventTimeInfo& operator=(ADF_EventTimeInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(ADF_EventTimeInfo& a, ADF_EventTimeInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(ADF_EventTimeInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ADF_EventTimeInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ADF_EventTimeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADF_EventTimeInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADF_EventTimeInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADF_EventTimeInfo& from) {
    ADF_EventTimeInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ADF_EventTimeInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.ADF_EventTimeInfo";
  }
  protected:
  explicit ADF_EventTimeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kStartTimeFieldNumber = 1,
    kEndTimeFieldNumber = 2,
    kStartTimeConfidenceFieldNumber = 3,
    kEndTimeConfidenceFieldNumber = 4,
    kUpdateTimeFieldNumber = 5,
  };
  // uint64 startTime = 1;
  void clear_starttime();
  uint64_t starttime() const;
  void set_starttime(uint64_t value);
  private:
  uint64_t _internal_starttime() const;
  void _internal_set_starttime(uint64_t value);
  public:

  // uint64 endTime = 2;
  void clear_endtime();
  uint64_t endtime() const;
  void set_endtime(uint64_t value);
  private:
  uint64_t _internal_endtime() const;
  void _internal_set_endtime(uint64_t value);
  public:

  // float startTimeConfidence = 3;
  void clear_starttimeconfidence();
  float starttimeconfidence() const;
  void set_starttimeconfidence(float value);
  private:
  float _internal_starttimeconfidence() const;
  void _internal_set_starttimeconfidence(float value);
  public:

  // float endTimeConfidence = 4;
  void clear_endtimeconfidence();
  float endtimeconfidence() const;
  void set_endtimeconfidence(float value);
  private:
  float _internal_endtimeconfidence() const;
  void _internal_set_endtimeconfidence(float value);
  public:

  // uint64 updateTime = 5;
  void clear_updatetime();
  uint64_t updatetime() const;
  void set_updatetime(uint64_t value);
  private:
  uint64_t _internal_updatetime() const;
  void _internal_set_updatetime(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SDF.ADF_EventTimeInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint64_t starttime_;
    uint64_t endtime_;
    float starttimeconfidence_;
    float endtimeconfidence_;
    uint64_t updatetime_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class ADF_EventInfoSource final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.ADF_EventInfoSource) */ {
 public:
  inline ADF_EventInfoSource() : ADF_EventInfoSource(nullptr) {}
  ~ADF_EventInfoSource() override;
  explicit PROTOBUF_CONSTEXPR ADF_EventInfoSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ADF_EventInfoSource& operator=(const ADF_EventInfoSource& from) {
    CopyFrom(from);
    return *this;
  }
  inline ADF_EventInfoSource& operator=(ADF_EventInfoSource&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(ADF_EventInfoSource& a, ADF_EventInfoSource& b) {
    a.Swap(&b);
  }
  inline void Swap(ADF_EventInfoSource* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ADF_EventInfoSource* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ADF_EventInfoSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADF_EventInfoSource>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADF_EventInfoSource& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADF_EventInfoSource& from) {
    ADF_EventInfoSource::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ADF_EventInfoSource* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.ADF_EventInfoSource";
  }
  protected:
  explicit ADF_EventInfoSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSourceTerminalIDFieldNumber = 2,
    kSourceVehicleIDFieldNumber = 3,
    kSourceRoadSideIDFieldNumber = 4,
    kSourceProviderIDFieldNumber = 5,
    kSourceUserIDFieldNumber = 6,
    kSourceTypeFieldNumber = 1,
  };
  // string sourceTerminalID = 2;
  void clear_sourceterminalid();
  const std::string& sourceterminalid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceterminalid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceterminalid();
  PROTOBUF_NODISCARD std::string* release_sourceterminalid();
  void set_allocated_sourceterminalid(std::string* sourceterminalid);
  private:
  const std::string& _internal_sourceterminalid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceterminalid(const std::string& value);
  std::string* _internal_mutable_sourceterminalid();
  public:

  // string sourceVehicleID = 3;
  void clear_sourcevehicleid();
  const std::string& sourcevehicleid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourcevehicleid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourcevehicleid();
  PROTOBUF_NODISCARD std::string* release_sourcevehicleid();
  void set_allocated_sourcevehicleid(std::string* sourcevehicleid);
  private:
  const std::string& _internal_sourcevehicleid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourcevehicleid(const std::string& value);
  std::string* _internal_mutable_sourcevehicleid();
  public:

  // string sourceRoadSideID = 4;
  void clear_sourceroadsideid();
  const std::string& sourceroadsideid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceroadsideid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceroadsideid();
  PROTOBUF_NODISCARD std::string* release_sourceroadsideid();
  void set_allocated_sourceroadsideid(std::string* sourceroadsideid);
  private:
  const std::string& _internal_sourceroadsideid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceroadsideid(const std::string& value);
  std::string* _internal_mutable_sourceroadsideid();
  public:

  // string sourceProviderID = 5;
  void clear_sourceproviderid();
  const std::string& sourceproviderid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceproviderid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceproviderid();
  PROTOBUF_NODISCARD std::string* release_sourceproviderid();
  void set_allocated_sourceproviderid(std::string* sourceproviderid);
  private:
  const std::string& _internal_sourceproviderid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceproviderid(const std::string& value);
  std::string* _internal_mutable_sourceproviderid();
  public:

  // string sourceUserID = 6;
  void clear_sourceuserid();
  const std::string& sourceuserid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceuserid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceuserid();
  PROTOBUF_NODISCARD std::string* release_sourceuserid();
  void set_allocated_sourceuserid(std::string* sourceuserid);
  private:
  const std::string& _internal_sourceuserid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceuserid(const std::string& value);
  std::string* _internal_mutable_sourceuserid();
  public:

  // uint64 sourceType = 1;
  void clear_sourcetype();
  uint64_t sourcetype() const;
  void set_sourcetype(uint64_t value);
  private:
  uint64_t _internal_sourcetype() const;
  void _internal_set_sourcetype(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:SDF.ADF_EventInfoSource)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceterminalid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourcevehicleid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceroadsideid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceproviderid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceuserid_;
    uint64_t sourcetype_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class ADF_TrafficLightPhaseStage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.ADF_TrafficLightPhaseStage) */ {
 public:
  inline ADF_TrafficLightPhaseStage() : ADF_TrafficLightPhaseStage(nullptr) {}
  ~ADF_TrafficLightPhaseStage() override;
  explicit PROTOBUF_CONSTEXPR ADF_TrafficLightPhaseStage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ADF_TrafficLightPhaseStage& operator=(const ADF_TrafficLightPhaseStage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ADF_TrafficLightPhaseStage& operator=(ADF_TrafficLightPhaseStage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(ADF_TrafficLightPhaseStage& a, ADF_TrafficLightPhaseStage& b) {
    a.Swap(&b);
  }
  inline void Swap(ADF_TrafficLightPhaseStage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ADF_TrafficLightPhaseStage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ADF_TrafficLightPhaseStage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADF_TrafficLightPhaseStage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADF_TrafficLightPhaseStage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADF_TrafficLightPhaseStage& from) {
    ADF_TrafficLightPhaseStage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ADF_TrafficLightPhaseStage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.ADF_TrafficLightPhaseStage";
  }
  protected:
  explicit ADF_TrafficLightPhaseStage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef ADF_TrafficLightPhaseStage_TrafficLightColorType TrafficLightColorType;
  static constexpr TrafficLightColorType UNKNOWN =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_UNKNOWN;
  static constexpr TrafficLightColorType BLACK =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_BLACK;
  static constexpr TrafficLightColorType RED =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_RED;
  static constexpr TrafficLightColorType RED_FLASH =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_RED_FLASH;
  static constexpr TrafficLightColorType YELLOW =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_YELLOW;
  static constexpr TrafficLightColorType YELLOW_FLASH =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_YELLOW_FLASH;
  static constexpr TrafficLightColorType GREEN =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_GREEN;
  static constexpr TrafficLightColorType GREEN_FLASH =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_GREEN_FLASH;
  static inline bool TrafficLightColorType_IsValid(int value) {
    return ADF_TrafficLightPhaseStage_TrafficLightColorType_IsValid(value);
  }
  static constexpr TrafficLightColorType TrafficLightColorType_MIN =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_MIN;
  static constexpr TrafficLightColorType TrafficLightColorType_MAX =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_MAX;
  static constexpr int TrafficLightColorType_ARRAYSIZE =
    ADF_TrafficLightPhaseStage_TrafficLightColorType_TrafficLightColorType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  TrafficLightColorType_descriptor() {
    return ADF_TrafficLightPhaseStage_TrafficLightColorType_descriptor();
  }
  template<typename T>
  static inline const std::string& TrafficLightColorType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TrafficLightColorType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TrafficLightColorType_Name.");
    return ADF_TrafficLightPhaseStage_TrafficLightColorType_Name(enum_t_value);
  }
  static inline bool TrafficLightColorType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TrafficLightColorType* value) {
    return ADF_TrafficLightPhaseStage_TrafficLightColorType_Parse(name, value);
  }

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

  enum : int {
    kSwitchingTimeFieldNumber = 2,
    kLightColorFieldNumber = 1,
    kNextColorFieldNumber = 3,
  };
  // uint64 switchingTime = 2;
  void clear_switchingtime();
  uint64_t switchingtime() const;
  void set_switchingtime(uint64_t value);
  private:
  uint64_t _internal_switchingtime() const;
  void _internal_set_switchingtime(uint64_t value);
  public:

  // .SDF.ADF_TrafficLightPhaseStage.TrafficLightColorType lightColor = 1;
  void clear_lightcolor();
  ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType lightcolor() const;
  void set_lightcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value);
  private:
  ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType _internal_lightcolor() const;
  void _internal_set_lightcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value);
  public:

  // .SDF.ADF_TrafficLightPhaseStage.TrafficLightColorType nextColor = 3;
  void clear_nextcolor();
  ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType nextcolor() const;
  void set_nextcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value);
  private:
  ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType _internal_nextcolor() const;
  void _internal_set_nextcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value);
  public:

  // @@protoc_insertion_point(class_scope:SDF.ADF_TrafficLightPhaseStage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint64_t switchingtime_;
    int lightcolor_;
    int nextcolor_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class EDF_TrafficLightRealTimeInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.EDF_TrafficLightRealTimeInfo) */ {
 public:
  inline EDF_TrafficLightRealTimeInfo() : EDF_TrafficLightRealTimeInfo(nullptr) {}
  ~EDF_TrafficLightRealTimeInfo() override;
  explicit PROTOBUF_CONSTEXPR EDF_TrafficLightRealTimeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline EDF_TrafficLightRealTimeInfo& operator=(const EDF_TrafficLightRealTimeInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline EDF_TrafficLightRealTimeInfo& operator=(EDF_TrafficLightRealTimeInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(EDF_TrafficLightRealTimeInfo& a, EDF_TrafficLightRealTimeInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(EDF_TrafficLightRealTimeInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EDF_TrafficLightRealTimeInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  EDF_TrafficLightRealTimeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EDF_TrafficLightRealTimeInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EDF_TrafficLightRealTimeInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EDF_TrafficLightRealTimeInfo& from) {
    EDF_TrafficLightRealTimeInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(EDF_TrafficLightRealTimeInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.EDF_TrafficLightRealTimeInfo";
  }
  protected:
  explicit EDF_TrafficLightRealTimeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kEventIDFieldNumber = 1,
    kTrafficLightIDFieldNumber = 2,
    kLightBulbIDFieldNumber = 3,
    kTimeInfoFieldNumber = 4,
    kPhaseStageFieldNumber = 5,
    kEventInfoSourceFieldNumber = 6,
  };
  // string eventID = 1;
  void clear_eventid();
  const std::string& eventid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eventid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eventid();
  PROTOBUF_NODISCARD std::string* release_eventid();
  void set_allocated_eventid(std::string* eventid);
  private:
  const std::string& _internal_eventid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eventid(const std::string& value);
  std::string* _internal_mutable_eventid();
  public:

  // string trafficLightID = 2;
  void clear_trafficlightid();
  const std::string& trafficlightid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_trafficlightid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_trafficlightid();
  PROTOBUF_NODISCARD std::string* release_trafficlightid();
  void set_allocated_trafficlightid(std::string* trafficlightid);
  private:
  const std::string& _internal_trafficlightid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_trafficlightid(const std::string& value);
  std::string* _internal_mutable_trafficlightid();
  public:

  // string lightBulbID = 3;
  void clear_lightbulbid();
  const std::string& lightbulbid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lightbulbid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lightbulbid();
  PROTOBUF_NODISCARD std::string* release_lightbulbid();
  void set_allocated_lightbulbid(std::string* lightbulbid);
  private:
  const std::string& _internal_lightbulbid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lightbulbid(const std::string& value);
  std::string* _internal_mutable_lightbulbid();
  public:

  // .SDF.ADF_EventTimeInfo timeInfo = 4;
  bool has_timeinfo() const;
  private:
  bool _internal_has_timeinfo() const;
  public:
  void clear_timeinfo();
  const ::SDF::ADF_EventTimeInfo& timeinfo() const;
  PROTOBUF_NODISCARD ::SDF::ADF_EventTimeInfo* release_timeinfo();
  ::SDF::ADF_EventTimeInfo* mutable_timeinfo();
  void set_allocated_timeinfo(::SDF::ADF_EventTimeInfo* timeinfo);
  private:
  const ::SDF::ADF_EventTimeInfo& _internal_timeinfo() const;
  ::SDF::ADF_EventTimeInfo* _internal_mutable_timeinfo();
  public:
  void unsafe_arena_set_allocated_timeinfo(
      ::SDF::ADF_EventTimeInfo* timeinfo);
  ::SDF::ADF_EventTimeInfo* unsafe_arena_release_timeinfo();

  // .SDF.ADF_TrafficLightPhaseStage phaseStage = 5;
  bool has_phasestage() const;
  private:
  bool _internal_has_phasestage() const;
  public:
  void clear_phasestage();
  const ::SDF::ADF_TrafficLightPhaseStage& phasestage() const;
  PROTOBUF_NODISCARD ::SDF::ADF_TrafficLightPhaseStage* release_phasestage();
  ::SDF::ADF_TrafficLightPhaseStage* mutable_phasestage();
  void set_allocated_phasestage(::SDF::ADF_TrafficLightPhaseStage* phasestage);
  private:
  const ::SDF::ADF_TrafficLightPhaseStage& _internal_phasestage() const;
  ::SDF::ADF_TrafficLightPhaseStage* _internal_mutable_phasestage();
  public:
  void unsafe_arena_set_allocated_phasestage(
      ::SDF::ADF_TrafficLightPhaseStage* phasestage);
  ::SDF::ADF_TrafficLightPhaseStage* unsafe_arena_release_phasestage();

  // .SDF.ADF_EventInfoSource eventInfoSource = 6;
  bool has_eventinfosource() const;
  private:
  bool _internal_has_eventinfosource() const;
  public:
  void clear_eventinfosource();
  const ::SDF::ADF_EventInfoSource& eventinfosource() const;
  PROTOBUF_NODISCARD ::SDF::ADF_EventInfoSource* release_eventinfosource();
  ::SDF::ADF_EventInfoSource* mutable_eventinfosource();
  void set_allocated_eventinfosource(::SDF::ADF_EventInfoSource* eventinfosource);
  private:
  const ::SDF::ADF_EventInfoSource& _internal_eventinfosource() const;
  ::SDF::ADF_EventInfoSource* _internal_mutable_eventinfosource();
  public:
  void unsafe_arena_set_allocated_eventinfosource(
      ::SDF::ADF_EventInfoSource* eventinfosource);
  ::SDF::ADF_EventInfoSource* unsafe_arena_release_eventinfosource();

  // @@protoc_insertion_point(class_scope:SDF.EDF_TrafficLightRealTimeInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eventid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trafficlightid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lightbulbid_;
    ::SDF::ADF_EventTimeInfo* timeinfo_;
    ::SDF::ADF_TrafficLightPhaseStage* phasestage_;
    ::SDF::ADF_EventInfoSource* eventinfosource_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class TrafficLightLayer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.TrafficLightLayer) */ {
 public:
  inline TrafficLightLayer() : TrafficLightLayer(nullptr) {}
  ~TrafficLightLayer() override;
  explicit PROTOBUF_CONSTEXPR TrafficLightLayer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TrafficLightLayer& operator=(const TrafficLightLayer& from) {
    CopyFrom(from);
    return *this;
  }
  inline TrafficLightLayer& operator=(TrafficLightLayer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(TrafficLightLayer& a, TrafficLightLayer& b) {
    a.Swap(&b);
  }
  inline void Swap(TrafficLightLayer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TrafficLightLayer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TrafficLightLayer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TrafficLightLayer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TrafficLightLayer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TrafficLightLayer& from) {
    TrafficLightLayer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TrafficLightLayer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.TrafficLightLayer";
  }
  protected:
  explicit TrafficLightLayer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTrafficLightRealTimeInfoLayerFieldNumber = 1,
  };
  // repeated .SDF.EDF_TrafficLightRealTimeInfo trafficLightRealTimeInfoLayer = 1;
  int trafficlightrealtimeinfolayer_size() const;
  private:
  int _internal_trafficlightrealtimeinfolayer_size() const;
  public:
  void clear_trafficlightrealtimeinfolayer();
  ::SDF::EDF_TrafficLightRealTimeInfo* mutable_trafficlightrealtimeinfolayer(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >*
      mutable_trafficlightrealtimeinfolayer();
  private:
  const ::SDF::EDF_TrafficLightRealTimeInfo& _internal_trafficlightrealtimeinfolayer(int index) const;
  ::SDF::EDF_TrafficLightRealTimeInfo* _internal_add_trafficlightrealtimeinfolayer();
  public:
  const ::SDF::EDF_TrafficLightRealTimeInfo& trafficlightrealtimeinfolayer(int index) const;
  ::SDF::EDF_TrafficLightRealTimeInfo* add_trafficlightrealtimeinfolayer();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >&
      trafficlightrealtimeinfolayer() const;

  // @@protoc_insertion_point(class_scope:SDF.TrafficLightLayer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo > trafficlightrealtimeinfolayer_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class RequestSequence final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.RequestSequence) */ {
 public:
  inline RequestSequence() : RequestSequence(nullptr) {}
  ~RequestSequence() override;
  explicit PROTOBUF_CONSTEXPR RequestSequence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline RequestSequence& operator=(const RequestSequence& from) {
    CopyFrom(from);
    return *this;
  }
  inline RequestSequence& operator=(RequestSequence&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(RequestSequence& a, RequestSequence& b) {
    a.Swap(&b);
  }
  inline void Swap(RequestSequence* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RequestSequence* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RequestSequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RequestSequence>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RequestSequence& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RequestSequence& from) {
    RequestSequence::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RequestSequence* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.RequestSequence";
  }
  protected:
  explicit RequestSequence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kListOfRequestFieldNumber = 2,
    kRequestIDFieldNumber = 1,
  };
  // repeated .SDF.EDF_TrafficLightRealTimeInfo listOfRequest = 2;
  int listofrequest_size() const;
  private:
  int _internal_listofrequest_size() const;
  public:
  void clear_listofrequest();
  ::SDF::EDF_TrafficLightRealTimeInfo* mutable_listofrequest(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >*
      mutable_listofrequest();
  private:
  const ::SDF::EDF_TrafficLightRealTimeInfo& _internal_listofrequest(int index) const;
  ::SDF::EDF_TrafficLightRealTimeInfo* _internal_add_listofrequest();
  public:
  const ::SDF::EDF_TrafficLightRealTimeInfo& listofrequest(int index) const;
  ::SDF::EDF_TrafficLightRealTimeInfo* add_listofrequest();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >&
      listofrequest() const;

  // string requestID = 1;
  void clear_requestid();
  const std::string& requestid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_requestid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_requestid();
  PROTOBUF_NODISCARD std::string* release_requestid();
  void set_allocated_requestid(std::string* requestid);
  private:
  const std::string& _internal_requestid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestid(const std::string& value);
  std::string* _internal_mutable_requestid();
  public:

  // @@protoc_insertion_point(class_scope:SDF.RequestSequence)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo > listofrequest_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestid_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// -------------------------------------------------------------------

class TrafficLightLayerResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:SDF.TrafficLightLayerResponse) */ {
 public:
  inline TrafficLightLayerResponse() : TrafficLightLayerResponse(nullptr) {}
  ~TrafficLightLayerResponse() override;
  explicit PROTOBUF_CONSTEXPR TrafficLightLayerResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TrafficLightLayerResponse& operator=(const TrafficLightLayerResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline TrafficLightLayerResponse& operator=(TrafficLightLayerResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  friend void swap(TrafficLightLayerResponse& a, TrafficLightLayerResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(TrafficLightLayerResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TrafficLightLayerResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TrafficLightLayerResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TrafficLightLayerResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TrafficLightLayerResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TrafficLightLayerResponse& from) {
    TrafficLightLayerResponse::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TrafficLightLayerResponse* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SDF.TrafficLightLayerResponse";
  }
  protected:
  explicit TrafficLightLayerResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRequestSequenceFieldNumber = 2,
    kErrorCodeFieldNumber = 1,
  };
  // .SDF.RequestSequence requestSequence = 2;
  bool has_requestsequence() const;
  private:
  bool _internal_has_requestsequence() const;
  public:
  void clear_requestsequence();
  const ::SDF::RequestSequence& requestsequence() const;
  PROTOBUF_NODISCARD ::SDF::RequestSequence* release_requestsequence();
  ::SDF::RequestSequence* mutable_requestsequence();
  void set_allocated_requestsequence(::SDF::RequestSequence* requestsequence);
  private:
  const ::SDF::RequestSequence& _internal_requestsequence() const;
  ::SDF::RequestSequence* _internal_mutable_requestsequence();
  public:
  void unsafe_arena_set_allocated_requestsequence(
      ::SDF::RequestSequence* requestsequence);
  ::SDF::RequestSequence* unsafe_arena_release_requestsequence();

  // int32 errorCode = 1;
  void clear_errorcode();
  int32_t errorcode() const;
  void set_errorcode(int32_t value);
  private:
  int32_t _internal_errorcode() const;
  void _internal_set_errorcode(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:SDF.TrafficLightLayerResponse)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::SDF::RequestSequence* requestsequence_;
    int32_t errorcode_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sdf_2eproto;
};
// ===================================================================


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

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

// uint64 startTime = 1;
inline void ADF_EventTimeInfo::clear_starttime() {
  _impl_.starttime_ = uint64_t{0u};
}
inline uint64_t ADF_EventTimeInfo::_internal_starttime() const {
  return _impl_.starttime_;
}
inline uint64_t ADF_EventTimeInfo::starttime() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventTimeInfo.startTime)
  return _internal_starttime();
}
inline void ADF_EventTimeInfo::_internal_set_starttime(uint64_t value) {
  
  _impl_.starttime_ = value;
}
inline void ADF_EventTimeInfo::set_starttime(uint64_t value) {
  _internal_set_starttime(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventTimeInfo.startTime)
}

// uint64 endTime = 2;
inline void ADF_EventTimeInfo::clear_endtime() {
  _impl_.endtime_ = uint64_t{0u};
}
inline uint64_t ADF_EventTimeInfo::_internal_endtime() const {
  return _impl_.endtime_;
}
inline uint64_t ADF_EventTimeInfo::endtime() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventTimeInfo.endTime)
  return _internal_endtime();
}
inline void ADF_EventTimeInfo::_internal_set_endtime(uint64_t value) {
  
  _impl_.endtime_ = value;
}
inline void ADF_EventTimeInfo::set_endtime(uint64_t value) {
  _internal_set_endtime(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventTimeInfo.endTime)
}

// float startTimeConfidence = 3;
inline void ADF_EventTimeInfo::clear_starttimeconfidence() {
  _impl_.starttimeconfidence_ = 0;
}
inline float ADF_EventTimeInfo::_internal_starttimeconfidence() const {
  return _impl_.starttimeconfidence_;
}
inline float ADF_EventTimeInfo::starttimeconfidence() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventTimeInfo.startTimeConfidence)
  return _internal_starttimeconfidence();
}
inline void ADF_EventTimeInfo::_internal_set_starttimeconfidence(float value) {
  
  _impl_.starttimeconfidence_ = value;
}
inline void ADF_EventTimeInfo::set_starttimeconfidence(float value) {
  _internal_set_starttimeconfidence(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventTimeInfo.startTimeConfidence)
}

// float endTimeConfidence = 4;
inline void ADF_EventTimeInfo::clear_endtimeconfidence() {
  _impl_.endtimeconfidence_ = 0;
}
inline float ADF_EventTimeInfo::_internal_endtimeconfidence() const {
  return _impl_.endtimeconfidence_;
}
inline float ADF_EventTimeInfo::endtimeconfidence() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventTimeInfo.endTimeConfidence)
  return _internal_endtimeconfidence();
}
inline void ADF_EventTimeInfo::_internal_set_endtimeconfidence(float value) {
  
  _impl_.endtimeconfidence_ = value;
}
inline void ADF_EventTimeInfo::set_endtimeconfidence(float value) {
  _internal_set_endtimeconfidence(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventTimeInfo.endTimeConfidence)
}

// uint64 updateTime = 5;
inline void ADF_EventTimeInfo::clear_updatetime() {
  _impl_.updatetime_ = uint64_t{0u};
}
inline uint64_t ADF_EventTimeInfo::_internal_updatetime() const {
  return _impl_.updatetime_;
}
inline uint64_t ADF_EventTimeInfo::updatetime() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventTimeInfo.updateTime)
  return _internal_updatetime();
}
inline void ADF_EventTimeInfo::_internal_set_updatetime(uint64_t value) {
  
  _impl_.updatetime_ = value;
}
inline void ADF_EventTimeInfo::set_updatetime(uint64_t value) {
  _internal_set_updatetime(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventTimeInfo.updateTime)
}

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

// ADF_EventInfoSource

// uint64 sourceType = 1;
inline void ADF_EventInfoSource::clear_sourcetype() {
  _impl_.sourcetype_ = uint64_t{0u};
}
inline uint64_t ADF_EventInfoSource::_internal_sourcetype() const {
  return _impl_.sourcetype_;
}
inline uint64_t ADF_EventInfoSource::sourcetype() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceType)
  return _internal_sourcetype();
}
inline void ADF_EventInfoSource::_internal_set_sourcetype(uint64_t value) {
  
  _impl_.sourcetype_ = value;
}
inline void ADF_EventInfoSource::set_sourcetype(uint64_t value) {
  _internal_set_sourcetype(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceType)
}

// string sourceTerminalID = 2;
inline void ADF_EventInfoSource::clear_sourceterminalid() {
  _impl_.sourceterminalid_.ClearToEmpty();
}
inline const std::string& ADF_EventInfoSource::sourceterminalid() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceTerminalID)
  return _internal_sourceterminalid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADF_EventInfoSource::set_sourceterminalid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sourceterminalid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceTerminalID)
}
inline std::string* ADF_EventInfoSource::mutable_sourceterminalid() {
  std::string* _s = _internal_mutable_sourceterminalid();
  // @@protoc_insertion_point(field_mutable:SDF.ADF_EventInfoSource.sourceTerminalID)
  return _s;
}
inline const std::string& ADF_EventInfoSource::_internal_sourceterminalid() const {
  return _impl_.sourceterminalid_.Get();
}
inline void ADF_EventInfoSource::_internal_set_sourceterminalid(const std::string& value) {
  
  _impl_.sourceterminalid_.Set(value, GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::_internal_mutable_sourceterminalid() {
  
  return _impl_.sourceterminalid_.Mutable(GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::release_sourceterminalid() {
  // @@protoc_insertion_point(field_release:SDF.ADF_EventInfoSource.sourceTerminalID)
  return _impl_.sourceterminalid_.Release();
}
inline void ADF_EventInfoSource::set_allocated_sourceterminalid(std::string* sourceterminalid) {
  if (sourceterminalid != nullptr) {
    
  } else {
    
  }
  _impl_.sourceterminalid_.SetAllocated(sourceterminalid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceterminalid_.IsDefault()) {
    _impl_.sourceterminalid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.ADF_EventInfoSource.sourceTerminalID)
}

// string sourceVehicleID = 3;
inline void ADF_EventInfoSource::clear_sourcevehicleid() {
  _impl_.sourcevehicleid_.ClearToEmpty();
}
inline const std::string& ADF_EventInfoSource::sourcevehicleid() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceVehicleID)
  return _internal_sourcevehicleid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADF_EventInfoSource::set_sourcevehicleid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sourcevehicleid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceVehicleID)
}
inline std::string* ADF_EventInfoSource::mutable_sourcevehicleid() {
  std::string* _s = _internal_mutable_sourcevehicleid();
  // @@protoc_insertion_point(field_mutable:SDF.ADF_EventInfoSource.sourceVehicleID)
  return _s;
}
inline const std::string& ADF_EventInfoSource::_internal_sourcevehicleid() const {
  return _impl_.sourcevehicleid_.Get();
}
inline void ADF_EventInfoSource::_internal_set_sourcevehicleid(const std::string& value) {
  
  _impl_.sourcevehicleid_.Set(value, GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::_internal_mutable_sourcevehicleid() {
  
  return _impl_.sourcevehicleid_.Mutable(GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::release_sourcevehicleid() {
  // @@protoc_insertion_point(field_release:SDF.ADF_EventInfoSource.sourceVehicleID)
  return _impl_.sourcevehicleid_.Release();
}
inline void ADF_EventInfoSource::set_allocated_sourcevehicleid(std::string* sourcevehicleid) {
  if (sourcevehicleid != nullptr) {
    
  } else {
    
  }
  _impl_.sourcevehicleid_.SetAllocated(sourcevehicleid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourcevehicleid_.IsDefault()) {
    _impl_.sourcevehicleid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.ADF_EventInfoSource.sourceVehicleID)
}

// string sourceRoadSideID = 4;
inline void ADF_EventInfoSource::clear_sourceroadsideid() {
  _impl_.sourceroadsideid_.ClearToEmpty();
}
inline const std::string& ADF_EventInfoSource::sourceroadsideid() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceRoadSideID)
  return _internal_sourceroadsideid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADF_EventInfoSource::set_sourceroadsideid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sourceroadsideid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceRoadSideID)
}
inline std::string* ADF_EventInfoSource::mutable_sourceroadsideid() {
  std::string* _s = _internal_mutable_sourceroadsideid();
  // @@protoc_insertion_point(field_mutable:SDF.ADF_EventInfoSource.sourceRoadSideID)
  return _s;
}
inline const std::string& ADF_EventInfoSource::_internal_sourceroadsideid() const {
  return _impl_.sourceroadsideid_.Get();
}
inline void ADF_EventInfoSource::_internal_set_sourceroadsideid(const std::string& value) {
  
  _impl_.sourceroadsideid_.Set(value, GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::_internal_mutable_sourceroadsideid() {
  
  return _impl_.sourceroadsideid_.Mutable(GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::release_sourceroadsideid() {
  // @@protoc_insertion_point(field_release:SDF.ADF_EventInfoSource.sourceRoadSideID)
  return _impl_.sourceroadsideid_.Release();
}
inline void ADF_EventInfoSource::set_allocated_sourceroadsideid(std::string* sourceroadsideid) {
  if (sourceroadsideid != nullptr) {
    
  } else {
    
  }
  _impl_.sourceroadsideid_.SetAllocated(sourceroadsideid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceroadsideid_.IsDefault()) {
    _impl_.sourceroadsideid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.ADF_EventInfoSource.sourceRoadSideID)
}

// string sourceProviderID = 5;
inline void ADF_EventInfoSource::clear_sourceproviderid() {
  _impl_.sourceproviderid_.ClearToEmpty();
}
inline const std::string& ADF_EventInfoSource::sourceproviderid() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceProviderID)
  return _internal_sourceproviderid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADF_EventInfoSource::set_sourceproviderid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sourceproviderid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceProviderID)
}
inline std::string* ADF_EventInfoSource::mutable_sourceproviderid() {
  std::string* _s = _internal_mutable_sourceproviderid();
  // @@protoc_insertion_point(field_mutable:SDF.ADF_EventInfoSource.sourceProviderID)
  return _s;
}
inline const std::string& ADF_EventInfoSource::_internal_sourceproviderid() const {
  return _impl_.sourceproviderid_.Get();
}
inline void ADF_EventInfoSource::_internal_set_sourceproviderid(const std::string& value) {
  
  _impl_.sourceproviderid_.Set(value, GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::_internal_mutable_sourceproviderid() {
  
  return _impl_.sourceproviderid_.Mutable(GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::release_sourceproviderid() {
  // @@protoc_insertion_point(field_release:SDF.ADF_EventInfoSource.sourceProviderID)
  return _impl_.sourceproviderid_.Release();
}
inline void ADF_EventInfoSource::set_allocated_sourceproviderid(std::string* sourceproviderid) {
  if (sourceproviderid != nullptr) {
    
  } else {
    
  }
  _impl_.sourceproviderid_.SetAllocated(sourceproviderid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceproviderid_.IsDefault()) {
    _impl_.sourceproviderid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.ADF_EventInfoSource.sourceProviderID)
}

// string sourceUserID = 6;
inline void ADF_EventInfoSource::clear_sourceuserid() {
  _impl_.sourceuserid_.ClearToEmpty();
}
inline const std::string& ADF_EventInfoSource::sourceuserid() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_EventInfoSource.sourceUserID)
  return _internal_sourceuserid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADF_EventInfoSource::set_sourceuserid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sourceuserid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.ADF_EventInfoSource.sourceUserID)
}
inline std::string* ADF_EventInfoSource::mutable_sourceuserid() {
  std::string* _s = _internal_mutable_sourceuserid();
  // @@protoc_insertion_point(field_mutable:SDF.ADF_EventInfoSource.sourceUserID)
  return _s;
}
inline const std::string& ADF_EventInfoSource::_internal_sourceuserid() const {
  return _impl_.sourceuserid_.Get();
}
inline void ADF_EventInfoSource::_internal_set_sourceuserid(const std::string& value) {
  
  _impl_.sourceuserid_.Set(value, GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::_internal_mutable_sourceuserid() {
  
  return _impl_.sourceuserid_.Mutable(GetArenaForAllocation());
}
inline std::string* ADF_EventInfoSource::release_sourceuserid() {
  // @@protoc_insertion_point(field_release:SDF.ADF_EventInfoSource.sourceUserID)
  return _impl_.sourceuserid_.Release();
}
inline void ADF_EventInfoSource::set_allocated_sourceuserid(std::string* sourceuserid) {
  if (sourceuserid != nullptr) {
    
  } else {
    
  }
  _impl_.sourceuserid_.SetAllocated(sourceuserid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceuserid_.IsDefault()) {
    _impl_.sourceuserid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.ADF_EventInfoSource.sourceUserID)
}

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

// ADF_TrafficLightPhaseStage

// .SDF.ADF_TrafficLightPhaseStage.TrafficLightColorType lightColor = 1;
inline void ADF_TrafficLightPhaseStage::clear_lightcolor() {
  _impl_.lightcolor_ = 0;
}
inline ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage::_internal_lightcolor() const {
  return static_cast< ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType >(_impl_.lightcolor_);
}
inline ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage::lightcolor() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_TrafficLightPhaseStage.lightColor)
  return _internal_lightcolor();
}
inline void ADF_TrafficLightPhaseStage::_internal_set_lightcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value) {
  
  _impl_.lightcolor_ = value;
}
inline void ADF_TrafficLightPhaseStage::set_lightcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value) {
  _internal_set_lightcolor(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_TrafficLightPhaseStage.lightColor)
}

// uint64 switchingTime = 2;
inline void ADF_TrafficLightPhaseStage::clear_switchingtime() {
  _impl_.switchingtime_ = uint64_t{0u};
}
inline uint64_t ADF_TrafficLightPhaseStage::_internal_switchingtime() const {
  return _impl_.switchingtime_;
}
inline uint64_t ADF_TrafficLightPhaseStage::switchingtime() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_TrafficLightPhaseStage.switchingTime)
  return _internal_switchingtime();
}
inline void ADF_TrafficLightPhaseStage::_internal_set_switchingtime(uint64_t value) {
  
  _impl_.switchingtime_ = value;
}
inline void ADF_TrafficLightPhaseStage::set_switchingtime(uint64_t value) {
  _internal_set_switchingtime(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_TrafficLightPhaseStage.switchingTime)
}

// .SDF.ADF_TrafficLightPhaseStage.TrafficLightColorType nextColor = 3;
inline void ADF_TrafficLightPhaseStage::clear_nextcolor() {
  _impl_.nextcolor_ = 0;
}
inline ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage::_internal_nextcolor() const {
  return static_cast< ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType >(_impl_.nextcolor_);
}
inline ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType ADF_TrafficLightPhaseStage::nextcolor() const {
  // @@protoc_insertion_point(field_get:SDF.ADF_TrafficLightPhaseStage.nextColor)
  return _internal_nextcolor();
}
inline void ADF_TrafficLightPhaseStage::_internal_set_nextcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value) {
  
  _impl_.nextcolor_ = value;
}
inline void ADF_TrafficLightPhaseStage::set_nextcolor(::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType value) {
  _internal_set_nextcolor(value);
  // @@protoc_insertion_point(field_set:SDF.ADF_TrafficLightPhaseStage.nextColor)
}

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

// EDF_TrafficLightRealTimeInfo

// string eventID = 1;
inline void EDF_TrafficLightRealTimeInfo::clear_eventid() {
  _impl_.eventid_.ClearToEmpty();
}
inline const std::string& EDF_TrafficLightRealTimeInfo::eventid() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.eventID)
  return _internal_eventid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EDF_TrafficLightRealTimeInfo::set_eventid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.eventid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.EDF_TrafficLightRealTimeInfo.eventID)
}
inline std::string* EDF_TrafficLightRealTimeInfo::mutable_eventid() {
  std::string* _s = _internal_mutable_eventid();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.eventID)
  return _s;
}
inline const std::string& EDF_TrafficLightRealTimeInfo::_internal_eventid() const {
  return _impl_.eventid_.Get();
}
inline void EDF_TrafficLightRealTimeInfo::_internal_set_eventid(const std::string& value) {
  
  _impl_.eventid_.Set(value, GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::_internal_mutable_eventid() {
  
  return _impl_.eventid_.Mutable(GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::release_eventid() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.eventID)
  return _impl_.eventid_.Release();
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_eventid(std::string* eventid) {
  if (eventid != nullptr) {
    
  } else {
    
  }
  _impl_.eventid_.SetAllocated(eventid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eventid_.IsDefault()) {
    _impl_.eventid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.eventID)
}

// string trafficLightID = 2;
inline void EDF_TrafficLightRealTimeInfo::clear_trafficlightid() {
  _impl_.trafficlightid_.ClearToEmpty();
}
inline const std::string& EDF_TrafficLightRealTimeInfo::trafficlightid() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.trafficLightID)
  return _internal_trafficlightid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EDF_TrafficLightRealTimeInfo::set_trafficlightid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.trafficlightid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.EDF_TrafficLightRealTimeInfo.trafficLightID)
}
inline std::string* EDF_TrafficLightRealTimeInfo::mutable_trafficlightid() {
  std::string* _s = _internal_mutable_trafficlightid();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.trafficLightID)
  return _s;
}
inline const std::string& EDF_TrafficLightRealTimeInfo::_internal_trafficlightid() const {
  return _impl_.trafficlightid_.Get();
}
inline void EDF_TrafficLightRealTimeInfo::_internal_set_trafficlightid(const std::string& value) {
  
  _impl_.trafficlightid_.Set(value, GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::_internal_mutable_trafficlightid() {
  
  return _impl_.trafficlightid_.Mutable(GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::release_trafficlightid() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.trafficLightID)
  return _impl_.trafficlightid_.Release();
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_trafficlightid(std::string* trafficlightid) {
  if (trafficlightid != nullptr) {
    
  } else {
    
  }
  _impl_.trafficlightid_.SetAllocated(trafficlightid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.trafficlightid_.IsDefault()) {
    _impl_.trafficlightid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.trafficLightID)
}

// string lightBulbID = 3;
inline void EDF_TrafficLightRealTimeInfo::clear_lightbulbid() {
  _impl_.lightbulbid_.ClearToEmpty();
}
inline const std::string& EDF_TrafficLightRealTimeInfo::lightbulbid() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.lightBulbID)
  return _internal_lightbulbid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EDF_TrafficLightRealTimeInfo::set_lightbulbid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.lightbulbid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.EDF_TrafficLightRealTimeInfo.lightBulbID)
}
inline std::string* EDF_TrafficLightRealTimeInfo::mutable_lightbulbid() {
  std::string* _s = _internal_mutable_lightbulbid();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.lightBulbID)
  return _s;
}
inline const std::string& EDF_TrafficLightRealTimeInfo::_internal_lightbulbid() const {
  return _impl_.lightbulbid_.Get();
}
inline void EDF_TrafficLightRealTimeInfo::_internal_set_lightbulbid(const std::string& value) {
  
  _impl_.lightbulbid_.Set(value, GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::_internal_mutable_lightbulbid() {
  
  return _impl_.lightbulbid_.Mutable(GetArenaForAllocation());
}
inline std::string* EDF_TrafficLightRealTimeInfo::release_lightbulbid() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.lightBulbID)
  return _impl_.lightbulbid_.Release();
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_lightbulbid(std::string* lightbulbid) {
  if (lightbulbid != nullptr) {
    
  } else {
    
  }
  _impl_.lightbulbid_.SetAllocated(lightbulbid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lightbulbid_.IsDefault()) {
    _impl_.lightbulbid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.lightBulbID)
}

// .SDF.ADF_EventTimeInfo timeInfo = 4;
inline bool EDF_TrafficLightRealTimeInfo::_internal_has_timeinfo() const {
  return this != internal_default_instance() && _impl_.timeinfo_ != nullptr;
}
inline bool EDF_TrafficLightRealTimeInfo::has_timeinfo() const {
  return _internal_has_timeinfo();
}
inline void EDF_TrafficLightRealTimeInfo::clear_timeinfo() {
  if (GetArenaForAllocation() == nullptr && _impl_.timeinfo_ != nullptr) {
    delete _impl_.timeinfo_;
  }
  _impl_.timeinfo_ = nullptr;
}
inline const ::SDF::ADF_EventTimeInfo& EDF_TrafficLightRealTimeInfo::_internal_timeinfo() const {
  const ::SDF::ADF_EventTimeInfo* p = _impl_.timeinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::SDF::ADF_EventTimeInfo&>(
      ::SDF::_ADF_EventTimeInfo_default_instance_);
}
inline const ::SDF::ADF_EventTimeInfo& EDF_TrafficLightRealTimeInfo::timeinfo() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.timeInfo)
  return _internal_timeinfo();
}
inline void EDF_TrafficLightRealTimeInfo::unsafe_arena_set_allocated_timeinfo(
    ::SDF::ADF_EventTimeInfo* timeinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.timeinfo_);
  }
  _impl_.timeinfo_ = timeinfo;
  if (timeinfo) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.timeInfo)
}
inline ::SDF::ADF_EventTimeInfo* EDF_TrafficLightRealTimeInfo::release_timeinfo() {
  
  ::SDF::ADF_EventTimeInfo* temp = _impl_.timeinfo_;
  _impl_.timeinfo_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::SDF::ADF_EventTimeInfo* EDF_TrafficLightRealTimeInfo::unsafe_arena_release_timeinfo() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.timeInfo)
  
  ::SDF::ADF_EventTimeInfo* temp = _impl_.timeinfo_;
  _impl_.timeinfo_ = nullptr;
  return temp;
}
inline ::SDF::ADF_EventTimeInfo* EDF_TrafficLightRealTimeInfo::_internal_mutable_timeinfo() {
  
  if (_impl_.timeinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::SDF::ADF_EventTimeInfo>(GetArenaForAllocation());
    _impl_.timeinfo_ = p;
  }
  return _impl_.timeinfo_;
}
inline ::SDF::ADF_EventTimeInfo* EDF_TrafficLightRealTimeInfo::mutable_timeinfo() {
  ::SDF::ADF_EventTimeInfo* _msg = _internal_mutable_timeinfo();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.timeInfo)
  return _msg;
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_timeinfo(::SDF::ADF_EventTimeInfo* timeinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.timeinfo_;
  }
  if (timeinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(timeinfo);
    if (message_arena != submessage_arena) {
      timeinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timeinfo, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.timeinfo_ = timeinfo;
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.timeInfo)
}

// .SDF.ADF_TrafficLightPhaseStage phaseStage = 5;
inline bool EDF_TrafficLightRealTimeInfo::_internal_has_phasestage() const {
  return this != internal_default_instance() && _impl_.phasestage_ != nullptr;
}
inline bool EDF_TrafficLightRealTimeInfo::has_phasestage() const {
  return _internal_has_phasestage();
}
inline void EDF_TrafficLightRealTimeInfo::clear_phasestage() {
  if (GetArenaForAllocation() == nullptr && _impl_.phasestage_ != nullptr) {
    delete _impl_.phasestage_;
  }
  _impl_.phasestage_ = nullptr;
}
inline const ::SDF::ADF_TrafficLightPhaseStage& EDF_TrafficLightRealTimeInfo::_internal_phasestage() const {
  const ::SDF::ADF_TrafficLightPhaseStage* p = _impl_.phasestage_;
  return p != nullptr ? *p : reinterpret_cast<const ::SDF::ADF_TrafficLightPhaseStage&>(
      ::SDF::_ADF_TrafficLightPhaseStage_default_instance_);
}
inline const ::SDF::ADF_TrafficLightPhaseStage& EDF_TrafficLightRealTimeInfo::phasestage() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.phaseStage)
  return _internal_phasestage();
}
inline void EDF_TrafficLightRealTimeInfo::unsafe_arena_set_allocated_phasestage(
    ::SDF::ADF_TrafficLightPhaseStage* phasestage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phasestage_);
  }
  _impl_.phasestage_ = phasestage;
  if (phasestage) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.phaseStage)
}
inline ::SDF::ADF_TrafficLightPhaseStage* EDF_TrafficLightRealTimeInfo::release_phasestage() {
  
  ::SDF::ADF_TrafficLightPhaseStage* temp = _impl_.phasestage_;
  _impl_.phasestage_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::SDF::ADF_TrafficLightPhaseStage* EDF_TrafficLightRealTimeInfo::unsafe_arena_release_phasestage() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.phaseStage)
  
  ::SDF::ADF_TrafficLightPhaseStage* temp = _impl_.phasestage_;
  _impl_.phasestage_ = nullptr;
  return temp;
}
inline ::SDF::ADF_TrafficLightPhaseStage* EDF_TrafficLightRealTimeInfo::_internal_mutable_phasestage() {
  
  if (_impl_.phasestage_ == nullptr) {
    auto* p = CreateMaybeMessage<::SDF::ADF_TrafficLightPhaseStage>(GetArenaForAllocation());
    _impl_.phasestage_ = p;
  }
  return _impl_.phasestage_;
}
inline ::SDF::ADF_TrafficLightPhaseStage* EDF_TrafficLightRealTimeInfo::mutable_phasestage() {
  ::SDF::ADF_TrafficLightPhaseStage* _msg = _internal_mutable_phasestage();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.phaseStage)
  return _msg;
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_phasestage(::SDF::ADF_TrafficLightPhaseStage* phasestage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.phasestage_;
  }
  if (phasestage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phasestage);
    if (message_arena != submessage_arena) {
      phasestage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, phasestage, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.phasestage_ = phasestage;
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.phaseStage)
}

// .SDF.ADF_EventInfoSource eventInfoSource = 6;
inline bool EDF_TrafficLightRealTimeInfo::_internal_has_eventinfosource() const {
  return this != internal_default_instance() && _impl_.eventinfosource_ != nullptr;
}
inline bool EDF_TrafficLightRealTimeInfo::has_eventinfosource() const {
  return _internal_has_eventinfosource();
}
inline void EDF_TrafficLightRealTimeInfo::clear_eventinfosource() {
  if (GetArenaForAllocation() == nullptr && _impl_.eventinfosource_ != nullptr) {
    delete _impl_.eventinfosource_;
  }
  _impl_.eventinfosource_ = nullptr;
}
inline const ::SDF::ADF_EventInfoSource& EDF_TrafficLightRealTimeInfo::_internal_eventinfosource() const {
  const ::SDF::ADF_EventInfoSource* p = _impl_.eventinfosource_;
  return p != nullptr ? *p : reinterpret_cast<const ::SDF::ADF_EventInfoSource&>(
      ::SDF::_ADF_EventInfoSource_default_instance_);
}
inline const ::SDF::ADF_EventInfoSource& EDF_TrafficLightRealTimeInfo::eventinfosource() const {
  // @@protoc_insertion_point(field_get:SDF.EDF_TrafficLightRealTimeInfo.eventInfoSource)
  return _internal_eventinfosource();
}
inline void EDF_TrafficLightRealTimeInfo::unsafe_arena_set_allocated_eventinfosource(
    ::SDF::ADF_EventInfoSource* eventinfosource) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eventinfosource_);
  }
  _impl_.eventinfosource_ = eventinfosource;
  if (eventinfosource) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.eventInfoSource)
}
inline ::SDF::ADF_EventInfoSource* EDF_TrafficLightRealTimeInfo::release_eventinfosource() {
  
  ::SDF::ADF_EventInfoSource* temp = _impl_.eventinfosource_;
  _impl_.eventinfosource_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::SDF::ADF_EventInfoSource* EDF_TrafficLightRealTimeInfo::unsafe_arena_release_eventinfosource() {
  // @@protoc_insertion_point(field_release:SDF.EDF_TrafficLightRealTimeInfo.eventInfoSource)
  
  ::SDF::ADF_EventInfoSource* temp = _impl_.eventinfosource_;
  _impl_.eventinfosource_ = nullptr;
  return temp;
}
inline ::SDF::ADF_EventInfoSource* EDF_TrafficLightRealTimeInfo::_internal_mutable_eventinfosource() {
  
  if (_impl_.eventinfosource_ == nullptr) {
    auto* p = CreateMaybeMessage<::SDF::ADF_EventInfoSource>(GetArenaForAllocation());
    _impl_.eventinfosource_ = p;
  }
  return _impl_.eventinfosource_;
}
inline ::SDF::ADF_EventInfoSource* EDF_TrafficLightRealTimeInfo::mutable_eventinfosource() {
  ::SDF::ADF_EventInfoSource* _msg = _internal_mutable_eventinfosource();
  // @@protoc_insertion_point(field_mutable:SDF.EDF_TrafficLightRealTimeInfo.eventInfoSource)
  return _msg;
}
inline void EDF_TrafficLightRealTimeInfo::set_allocated_eventinfosource(::SDF::ADF_EventInfoSource* eventinfosource) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.eventinfosource_;
  }
  if (eventinfosource) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(eventinfosource);
    if (message_arena != submessage_arena) {
      eventinfosource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eventinfosource, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.eventinfosource_ = eventinfosource;
  // @@protoc_insertion_point(field_set_allocated:SDF.EDF_TrafficLightRealTimeInfo.eventInfoSource)
}

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

// TrafficLightLayer

// repeated .SDF.EDF_TrafficLightRealTimeInfo trafficLightRealTimeInfoLayer = 1;
inline int TrafficLightLayer::_internal_trafficlightrealtimeinfolayer_size() const {
  return _impl_.trafficlightrealtimeinfolayer_.size();
}
inline int TrafficLightLayer::trafficlightrealtimeinfolayer_size() const {
  return _internal_trafficlightrealtimeinfolayer_size();
}
inline void TrafficLightLayer::clear_trafficlightrealtimeinfolayer() {
  _impl_.trafficlightrealtimeinfolayer_.Clear();
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* TrafficLightLayer::mutable_trafficlightrealtimeinfolayer(int index) {
  // @@protoc_insertion_point(field_mutable:SDF.TrafficLightLayer.trafficLightRealTimeInfoLayer)
  return _impl_.trafficlightrealtimeinfolayer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >*
TrafficLightLayer::mutable_trafficlightrealtimeinfolayer() {
  // @@protoc_insertion_point(field_mutable_list:SDF.TrafficLightLayer.trafficLightRealTimeInfoLayer)
  return &_impl_.trafficlightrealtimeinfolayer_;
}
inline const ::SDF::EDF_TrafficLightRealTimeInfo& TrafficLightLayer::_internal_trafficlightrealtimeinfolayer(int index) const {
  return _impl_.trafficlightrealtimeinfolayer_.Get(index);
}
inline const ::SDF::EDF_TrafficLightRealTimeInfo& TrafficLightLayer::trafficlightrealtimeinfolayer(int index) const {
  // @@protoc_insertion_point(field_get:SDF.TrafficLightLayer.trafficLightRealTimeInfoLayer)
  return _internal_trafficlightrealtimeinfolayer(index);
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* TrafficLightLayer::_internal_add_trafficlightrealtimeinfolayer() {
  return _impl_.trafficlightrealtimeinfolayer_.Add();
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* TrafficLightLayer::add_trafficlightrealtimeinfolayer() {
  ::SDF::EDF_TrafficLightRealTimeInfo* _add = _internal_add_trafficlightrealtimeinfolayer();
  // @@protoc_insertion_point(field_add:SDF.TrafficLightLayer.trafficLightRealTimeInfoLayer)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >&
TrafficLightLayer::trafficlightrealtimeinfolayer() const {
  // @@protoc_insertion_point(field_list:SDF.TrafficLightLayer.trafficLightRealTimeInfoLayer)
  return _impl_.trafficlightrealtimeinfolayer_;
}

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

// RequestSequence

// string requestID = 1;
inline void RequestSequence::clear_requestid() {
  _impl_.requestid_.ClearToEmpty();
}
inline const std::string& RequestSequence::requestid() const {
  // @@protoc_insertion_point(field_get:SDF.RequestSequence.requestID)
  return _internal_requestid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RequestSequence::set_requestid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.requestid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:SDF.RequestSequence.requestID)
}
inline std::string* RequestSequence::mutable_requestid() {
  std::string* _s = _internal_mutable_requestid();
  // @@protoc_insertion_point(field_mutable:SDF.RequestSequence.requestID)
  return _s;
}
inline const std::string& RequestSequence::_internal_requestid() const {
  return _impl_.requestid_.Get();
}
inline void RequestSequence::_internal_set_requestid(const std::string& value) {
  
  _impl_.requestid_.Set(value, GetArenaForAllocation());
}
inline std::string* RequestSequence::_internal_mutable_requestid() {
  
  return _impl_.requestid_.Mutable(GetArenaForAllocation());
}
inline std::string* RequestSequence::release_requestid() {
  // @@protoc_insertion_point(field_release:SDF.RequestSequence.requestID)
  return _impl_.requestid_.Release();
}
inline void RequestSequence::set_allocated_requestid(std::string* requestid) {
  if (requestid != nullptr) {
    
  } else {
    
  }
  _impl_.requestid_.SetAllocated(requestid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.requestid_.IsDefault()) {
    _impl_.requestid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:SDF.RequestSequence.requestID)
}

// repeated .SDF.EDF_TrafficLightRealTimeInfo listOfRequest = 2;
inline int RequestSequence::_internal_listofrequest_size() const {
  return _impl_.listofrequest_.size();
}
inline int RequestSequence::listofrequest_size() const {
  return _internal_listofrequest_size();
}
inline void RequestSequence::clear_listofrequest() {
  _impl_.listofrequest_.Clear();
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* RequestSequence::mutable_listofrequest(int index) {
  // @@protoc_insertion_point(field_mutable:SDF.RequestSequence.listOfRequest)
  return _impl_.listofrequest_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >*
RequestSequence::mutable_listofrequest() {
  // @@protoc_insertion_point(field_mutable_list:SDF.RequestSequence.listOfRequest)
  return &_impl_.listofrequest_;
}
inline const ::SDF::EDF_TrafficLightRealTimeInfo& RequestSequence::_internal_listofrequest(int index) const {
  return _impl_.listofrequest_.Get(index);
}
inline const ::SDF::EDF_TrafficLightRealTimeInfo& RequestSequence::listofrequest(int index) const {
  // @@protoc_insertion_point(field_get:SDF.RequestSequence.listOfRequest)
  return _internal_listofrequest(index);
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* RequestSequence::_internal_add_listofrequest() {
  return _impl_.listofrequest_.Add();
}
inline ::SDF::EDF_TrafficLightRealTimeInfo* RequestSequence::add_listofrequest() {
  ::SDF::EDF_TrafficLightRealTimeInfo* _add = _internal_add_listofrequest();
  // @@protoc_insertion_point(field_add:SDF.RequestSequence.listOfRequest)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::SDF::EDF_TrafficLightRealTimeInfo >&
RequestSequence::listofrequest() const {
  // @@protoc_insertion_point(field_list:SDF.RequestSequence.listOfRequest)
  return _impl_.listofrequest_;
}

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

// TrafficLightLayerResponse

// int32 errorCode = 1;
inline void TrafficLightLayerResponse::clear_errorcode() {
  _impl_.errorcode_ = 0;
}
inline int32_t TrafficLightLayerResponse::_internal_errorcode() const {
  return _impl_.errorcode_;
}
inline int32_t TrafficLightLayerResponse::errorcode() const {
  // @@protoc_insertion_point(field_get:SDF.TrafficLightLayerResponse.errorCode)
  return _internal_errorcode();
}
inline void TrafficLightLayerResponse::_internal_set_errorcode(int32_t value) {
  
  _impl_.errorcode_ = value;
}
inline void TrafficLightLayerResponse::set_errorcode(int32_t value) {
  _internal_set_errorcode(value);
  // @@protoc_insertion_point(field_set:SDF.TrafficLightLayerResponse.errorCode)
}

// .SDF.RequestSequence requestSequence = 2;
inline bool TrafficLightLayerResponse::_internal_has_requestsequence() const {
  return this != internal_default_instance() && _impl_.requestsequence_ != nullptr;
}
inline bool TrafficLightLayerResponse::has_requestsequence() const {
  return _internal_has_requestsequence();
}
inline void TrafficLightLayerResponse::clear_requestsequence() {
  if (GetArenaForAllocation() == nullptr && _impl_.requestsequence_ != nullptr) {
    delete _impl_.requestsequence_;
  }
  _impl_.requestsequence_ = nullptr;
}
inline const ::SDF::RequestSequence& TrafficLightLayerResponse::_internal_requestsequence() const {
  const ::SDF::RequestSequence* p = _impl_.requestsequence_;
  return p != nullptr ? *p : reinterpret_cast<const ::SDF::RequestSequence&>(
      ::SDF::_RequestSequence_default_instance_);
}
inline const ::SDF::RequestSequence& TrafficLightLayerResponse::requestsequence() const {
  // @@protoc_insertion_point(field_get:SDF.TrafficLightLayerResponse.requestSequence)
  return _internal_requestsequence();
}
inline void TrafficLightLayerResponse::unsafe_arena_set_allocated_requestsequence(
    ::SDF::RequestSequence* requestsequence) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestsequence_);
  }
  _impl_.requestsequence_ = requestsequence;
  if (requestsequence) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SDF.TrafficLightLayerResponse.requestSequence)
}
inline ::SDF::RequestSequence* TrafficLightLayerResponse::release_requestsequence() {
  
  ::SDF::RequestSequence* temp = _impl_.requestsequence_;
  _impl_.requestsequence_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::SDF::RequestSequence* TrafficLightLayerResponse::unsafe_arena_release_requestsequence() {
  // @@protoc_insertion_point(field_release:SDF.TrafficLightLayerResponse.requestSequence)
  
  ::SDF::RequestSequence* temp = _impl_.requestsequence_;
  _impl_.requestsequence_ = nullptr;
  return temp;
}
inline ::SDF::RequestSequence* TrafficLightLayerResponse::_internal_mutable_requestsequence() {
  
  if (_impl_.requestsequence_ == nullptr) {
    auto* p = CreateMaybeMessage<::SDF::RequestSequence>(GetArenaForAllocation());
    _impl_.requestsequence_ = p;
  }
  return _impl_.requestsequence_;
}
inline ::SDF::RequestSequence* TrafficLightLayerResponse::mutable_requestsequence() {
  ::SDF::RequestSequence* _msg = _internal_mutable_requestsequence();
  // @@protoc_insertion_point(field_mutable:SDF.TrafficLightLayerResponse.requestSequence)
  return _msg;
}
inline void TrafficLightLayerResponse::set_allocated_requestsequence(::SDF::RequestSequence* requestsequence) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestsequence_;
  }
  if (requestsequence) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestsequence);
    if (message_arena != submessage_arena) {
      requestsequence = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestsequence, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.requestsequence_ = requestsequence;
  // @@protoc_insertion_point(field_set_allocated:SDF.TrafficLightLayerResponse.requestSequence)
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace SDF

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType>() {
  return ::SDF::ADF_TrafficLightPhaseStage_TrafficLightColorType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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