clamp_safety/clamp_parameter.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_clamp_5fparameter_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_clamp_5fparameter_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#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 3013000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_clamp_5fparameter_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_clamp_5fparameter_2eproto;
namespace clamp_safety {
class LidarParameter;
class LidarParameterDefaultTypeInternal;
extern LidarParameterDefaultTypeInternal _LidarParameter_default_instance_;
class clamp_parameter;
class clamp_parameterDefaultTypeInternal;
extern clamp_parameterDefaultTypeInternal _clamp_parameter_default_instance_;
class lidar_box_limit;
class lidar_box_limitDefaultTypeInternal;
extern lidar_box_limitDefaultTypeInternal _lidar_box_limit_default_instance_;
class lidar_net;
class lidar_netDefaultTypeInternal;
extern lidar_netDefaultTypeInternal _lidar_net_default_instance_;
class local_net;
class local_netDefaultTypeInternal;
extern local_netDefaultTypeInternal _local_net_default_instance_;
class plc_net;
class plc_netDefaultTypeInternal;
extern plc_netDefaultTypeInternal _plc_net_default_instance_;
}  // namespace clamp_safety
PROTOBUF_NAMESPACE_OPEN
template<> ::clamp_safety::LidarParameter* Arena::CreateMaybeMessage<::clamp_safety::LidarParameter>(Arena*);
template<> ::clamp_safety::clamp_parameter* Arena::CreateMaybeMessage<::clamp_safety::clamp_parameter>(Arena*);
template<> ::clamp_safety::lidar_box_limit* Arena::CreateMaybeMessage<::clamp_safety::lidar_box_limit>(Arena*);
template<> ::clamp_safety::lidar_net* Arena::CreateMaybeMessage<::clamp_safety::lidar_net>(Arena*);
template<> ::clamp_safety::local_net* Arena::CreateMaybeMessage<::clamp_safety::local_net>(Arena*);
template<> ::clamp_safety::plc_net* Arena::CreateMaybeMessage<::clamp_safety::plc_net>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace clamp_safety {

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

class lidar_net PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.lidar_net) */ {
 public:
  inline lidar_net() : lidar_net(nullptr) {}
  virtual ~lidar_net();

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

  inline lidar_net& operator=(const lidar_net& from) {
    CopyFrom(from);
    return *this;
  }
  inline lidar_net& operator=(lidar_net&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const lidar_net& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const lidar_net* internal_default_instance() {
    return reinterpret_cast<const lidar_net*>(
               &_lidar_net_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  lidar_net* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<lidar_net>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const lidar_net& from);
  void MergeFrom(const lidar_net& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(lidar_net* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.lidar_net";
  }
  protected:
  explicit lidar_net(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIpAddressFieldNumber = 1,
    kPortFieldNumber = 2,
  };
  // optional string ip_address = 1 [default = ""];
  bool has_ip_address() const;
  private:
  bool _internal_has_ip_address() const;
  public:
  void clear_ip_address();
  const std::string& ip_address() const;
  void set_ip_address(const std::string& value);
  void set_ip_address(std::string&& value);
  void set_ip_address(const char* value);
  void set_ip_address(const char* value, size_t size);
  std::string* mutable_ip_address();
  std::string* release_ip_address();
  void set_allocated_ip_address(std::string* ip_address);
  private:
  const std::string& _internal_ip_address() const;
  void _internal_set_ip_address(const std::string& value);
  std::string* _internal_mutable_ip_address();
  public:

  // optional int32 port = 2 [default = 8000];
  bool has_port() const;
  private:
  bool _internal_has_port() const;
  public:
  void clear_port();
  ::PROTOBUF_NAMESPACE_ID::int32 port() const;
  void set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_port() const;
  void _internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:clamp_safety.lidar_net)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_address_;
  ::PROTOBUF_NAMESPACE_ID::int32 port_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// -------------------------------------------------------------------

class lidar_box_limit PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.lidar_box_limit) */ {
 public:
  inline lidar_box_limit() : lidar_box_limit(nullptr) {}
  virtual ~lidar_box_limit();

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

  inline lidar_box_limit& operator=(const lidar_box_limit& from) {
    CopyFrom(from);
    return *this;
  }
  inline lidar_box_limit& operator=(lidar_box_limit&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const lidar_box_limit& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const lidar_box_limit* internal_default_instance() {
    return reinterpret_cast<const lidar_box_limit*>(
               &_lidar_box_limit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  lidar_box_limit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<lidar_box_limit>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const lidar_box_limit& from);
  void MergeFrom(const lidar_box_limit& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(lidar_box_limit* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.lidar_box_limit";
  }
  protected:
  explicit lidar_box_limit(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMaxyFieldNumber = 5,
    kDistLimitFieldNumber = 1,
    kMinxFieldNumber = 2,
    kMaxxFieldNumber = 3,
    kMinyFieldNumber = 4,
  };
  // optional float maxy = 5 [default = 3.5];
  bool has_maxy() const;
  private:
  bool _internal_has_maxy() const;
  public:
  void clear_maxy();
  float maxy() const;
  void set_maxy(float value);
  private:
  float _internal_maxy() const;
  void _internal_set_maxy(float value);
  public:

  // optional float dist_limit = 1 [default = 8];
  bool has_dist_limit() const;
  private:
  bool _internal_has_dist_limit() const;
  public:
  void clear_dist_limit();
  float dist_limit() const;
  void set_dist_limit(float value);
  private:
  float _internal_dist_limit() const;
  void _internal_set_dist_limit(float value);
  public:

  // optional float minx = 2 [default = -6];
  bool has_minx() const;
  private:
  bool _internal_has_minx() const;
  public:
  void clear_minx();
  float minx() const;
  void set_minx(float value);
  private:
  float _internal_minx() const;
  void _internal_set_minx(float value);
  public:

  // optional float maxx = 3 [default = -0.2];
  bool has_maxx() const;
  private:
  bool _internal_has_maxx() const;
  public:
  void clear_maxx();
  float maxx() const;
  void set_maxx(float value);
  private:
  float _internal_maxx() const;
  void _internal_set_maxx(float value);
  public:

  // optional float miny = 4 [default = -3.5];
  bool has_miny() const;
  private:
  bool _internal_has_miny() const;
  public:
  void clear_miny();
  float miny() const;
  void set_miny(float value);
  private:
  float _internal_miny() const;
  void _internal_set_miny(float value);
  public:

  // @@protoc_insertion_point(class_scope:clamp_safety.lidar_box_limit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float maxy_;
  float dist_limit_;
  float minx_;
  float maxx_;
  float miny_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// -------------------------------------------------------------------

class LidarParameter PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.LidarParameter) */ {
 public:
  inline LidarParameter() : LidarParameter(nullptr) {}
  virtual ~LidarParameter();

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

  inline LidarParameter& operator=(const LidarParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline LidarParameter& operator=(LidarParameter&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LidarParameter& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LidarParameter* internal_default_instance() {
    return reinterpret_cast<const LidarParameter*>(
               &_LidarParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  LidarParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LidarParameter>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LidarParameter& from);
  void MergeFrom(const LidarParameter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LidarParameter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.LidarParameter";
  }
  protected:
  explicit LidarParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNetConfigFieldNumber = 7,
    kScanBoxLimitFieldNumber = 8,
    kRangeMinFieldNumber = 5,
    kRangeMaxFieldNumber = 6,
    kAngleMinFieldNumber = 1,
    kAngleMaxFieldNumber = 2,
    kAngleIncrementFieldNumber = 3,
    kTimeIncrementFieldNumber = 4,
  };
  // required .clamp_safety.lidar_net net_config = 7;
  bool has_net_config() const;
  private:
  bool _internal_has_net_config() const;
  public:
  void clear_net_config();
  const ::clamp_safety::lidar_net& net_config() const;
  ::clamp_safety::lidar_net* release_net_config();
  ::clamp_safety::lidar_net* mutable_net_config();
  void set_allocated_net_config(::clamp_safety::lidar_net* net_config);
  private:
  const ::clamp_safety::lidar_net& _internal_net_config() const;
  ::clamp_safety::lidar_net* _internal_mutable_net_config();
  public:
  void unsafe_arena_set_allocated_net_config(
      ::clamp_safety::lidar_net* net_config);
  ::clamp_safety::lidar_net* unsafe_arena_release_net_config();

  // required .clamp_safety.lidar_box_limit scan_box_limit = 8;
  bool has_scan_box_limit() const;
  private:
  bool _internal_has_scan_box_limit() const;
  public:
  void clear_scan_box_limit();
  const ::clamp_safety::lidar_box_limit& scan_box_limit() const;
  ::clamp_safety::lidar_box_limit* release_scan_box_limit();
  ::clamp_safety::lidar_box_limit* mutable_scan_box_limit();
  void set_allocated_scan_box_limit(::clamp_safety::lidar_box_limit* scan_box_limit);
  private:
  const ::clamp_safety::lidar_box_limit& _internal_scan_box_limit() const;
  ::clamp_safety::lidar_box_limit* _internal_mutable_scan_box_limit();
  public:
  void unsafe_arena_set_allocated_scan_box_limit(
      ::clamp_safety::lidar_box_limit* scan_box_limit);
  ::clamp_safety::lidar_box_limit* unsafe_arena_release_scan_box_limit();

  // optional int32 range_min = 5 [default = 0];
  bool has_range_min() const;
  private:
  bool _internal_has_range_min() const;
  public:
  void clear_range_min();
  ::PROTOBUF_NAMESPACE_ID::int32 range_min() const;
  void set_range_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_range_min() const;
  void _internal_set_range_min(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 range_max = 6 [default = 30];
  bool has_range_max() const;
  private:
  bool _internal_has_range_max() const;
  public:
  void clear_range_max();
  ::PROTOBUF_NAMESPACE_ID::int32 range_max() const;
  void set_range_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_range_max() const;
  void _internal_set_range_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional float angle_min = 1 [default = -2.3561945];
  bool has_angle_min() const;
  private:
  bool _internal_has_angle_min() const;
  public:
  void clear_angle_min();
  float angle_min() const;
  void set_angle_min(float value);
  private:
  float _internal_angle_min() const;
  void _internal_set_angle_min(float value);
  public:

  // optional float angle_max = 2 [default = 2.3561945];
  bool has_angle_max() const;
  private:
  bool _internal_has_angle_max() const;
  public:
  void clear_angle_max();
  float angle_max() const;
  void set_angle_max(float value);
  private:
  float _internal_angle_max() const;
  void _internal_set_angle_max(float value);
  public:

  // optional float angle_increment = 3 [default = 0.00582];
  bool has_angle_increment() const;
  private:
  bool _internal_has_angle_increment() const;
  public:
  void clear_angle_increment();
  float angle_increment() const;
  void set_angle_increment(float value);
  private:
  float _internal_angle_increment() const;
  void _internal_set_angle_increment(float value);
  public:

  // optional float time_increment = 4 [default = 6.2e-05];
  bool has_time_increment() const;
  private:
  bool _internal_has_time_increment() const;
  public:
  void clear_time_increment();
  float time_increment() const;
  void set_time_increment(float value);
  private:
  float _internal_time_increment() const;
  void _internal_set_time_increment(float value);
  public:

  // @@protoc_insertion_point(class_scope:clamp_safety.LidarParameter)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::clamp_safety::lidar_net* net_config_;
  ::clamp_safety::lidar_box_limit* scan_box_limit_;
  ::PROTOBUF_NAMESPACE_ID::int32 range_min_;
  ::PROTOBUF_NAMESPACE_ID::int32 range_max_;
  float angle_min_;
  float angle_max_;
  float angle_increment_;
  float time_increment_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// -------------------------------------------------------------------

class plc_net PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.plc_net) */ {
 public:
  inline plc_net() : plc_net(nullptr) {}
  virtual ~plc_net();

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

  inline plc_net& operator=(const plc_net& from) {
    CopyFrom(from);
    return *this;
  }
  inline plc_net& operator=(plc_net&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const plc_net& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const plc_net* internal_default_instance() {
    return reinterpret_cast<const plc_net*>(
               &_plc_net_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  plc_net* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<plc_net>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const plc_net& from);
  void MergeFrom(const plc_net& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(plc_net* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.plc_net";
  }
  protected:
  explicit plc_net(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIpAddressFieldNumber = 1,
  };
  // optional string ip_address = 1 [default = ""];
  bool has_ip_address() const;
  private:
  bool _internal_has_ip_address() const;
  public:
  void clear_ip_address();
  const std::string& ip_address() const;
  void set_ip_address(const std::string& value);
  void set_ip_address(std::string&& value);
  void set_ip_address(const char* value);
  void set_ip_address(const char* value, size_t size);
  std::string* mutable_ip_address();
  std::string* release_ip_address();
  void set_allocated_ip_address(std::string* ip_address);
  private:
  const std::string& _internal_ip_address() const;
  void _internal_set_ip_address(const std::string& value);
  std::string* _internal_mutable_ip_address();
  public:

  // @@protoc_insertion_point(class_scope:clamp_safety.plc_net)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_address_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// -------------------------------------------------------------------

class local_net PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.local_net) */ {
 public:
  inline local_net() : local_net(nullptr) {}
  virtual ~local_net();

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

  inline local_net& operator=(const local_net& from) {
    CopyFrom(from);
    return *this;
  }
  inline local_net& operator=(local_net&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const local_net& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const local_net* internal_default_instance() {
    return reinterpret_cast<const local_net*>(
               &_local_net_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  local_net* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<local_net>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const local_net& from);
  void MergeFrom(const local_net& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(local_net* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.local_net";
  }
  protected:
  explicit local_net(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLocalIpFieldNumber = 1,
    kEthNameFieldNumber = 2,
  };
  // optional string local_ip = 1 [default = "10.211.0.1"];
  bool has_local_ip() const;
  private:
  bool _internal_has_local_ip() const;
  public:
  void clear_local_ip();
  const std::string& local_ip() const;
  void set_local_ip(const std::string& value);
  void set_local_ip(std::string&& value);
  void set_local_ip(const char* value);
  void set_local_ip(const char* value, size_t size);
  std::string* mutable_local_ip();
  std::string* release_local_ip();
  void set_allocated_local_ip(std::string* local_ip);
  private:
  const std::string& _internal_local_ip() const;
  void _internal_set_local_ip(const std::string& value);
  std::string* _internal_mutable_local_ip();
  public:

  // optional string eth_name = 2 [default = "eth0"];
  bool has_eth_name() const;
  private:
  bool _internal_has_eth_name() const;
  public:
  void clear_eth_name();
  const std::string& eth_name() const;
  void set_eth_name(const std::string& value);
  void set_eth_name(std::string&& value);
  void set_eth_name(const char* value);
  void set_eth_name(const char* value, size_t size);
  std::string* mutable_eth_name();
  std::string* release_eth_name();
  void set_allocated_eth_name(std::string* eth_name);
  private:
  const std::string& _internal_eth_name() const;
  void _internal_set_eth_name(const std::string& value);
  std::string* _internal_mutable_eth_name();
  public:

  // @@protoc_insertion_point(class_scope:clamp_safety.local_net)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_local_ip_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_ip_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_eth_name_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eth_name_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// -------------------------------------------------------------------

class clamp_parameter PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clamp_safety.clamp_parameter) */ {
 public:
  inline clamp_parameter() : clamp_parameter(nullptr) {}
  virtual ~clamp_parameter();

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

  inline clamp_parameter& operator=(const clamp_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline clamp_parameter& operator=(clamp_parameter&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const clamp_parameter& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const clamp_parameter* internal_default_instance() {
    return reinterpret_cast<const clamp_parameter*>(
               &_clamp_parameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

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

  clamp_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<clamp_parameter>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const clamp_parameter& from);
  void MergeFrom(const clamp_parameter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(clamp_parameter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "clamp_safety.clamp_parameter";
  }
  protected:
  explicit clamp_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_clamp_5fparameter_2eproto);
    return ::descriptor_table_clamp_5fparameter_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLidarsFieldNumber = 1,
    kPlcParameterFieldNumber = 2,
    kLocalParameterFieldNumber = 3,
  };
  // repeated .clamp_safety.LidarParameter lidars = 1;
  int lidars_size() const;
  private:
  int _internal_lidars_size() const;
  public:
  void clear_lidars();
  ::clamp_safety::LidarParameter* mutable_lidars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::clamp_safety::LidarParameter >*
      mutable_lidars();
  private:
  const ::clamp_safety::LidarParameter& _internal_lidars(int index) const;
  ::clamp_safety::LidarParameter* _internal_add_lidars();
  public:
  const ::clamp_safety::LidarParameter& lidars(int index) const;
  ::clamp_safety::LidarParameter* add_lidars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::clamp_safety::LidarParameter >&
      lidars() const;

  // required .clamp_safety.plc_net plc_parameter = 2;
  bool has_plc_parameter() const;
  private:
  bool _internal_has_plc_parameter() const;
  public:
  void clear_plc_parameter();
  const ::clamp_safety::plc_net& plc_parameter() const;
  ::clamp_safety::plc_net* release_plc_parameter();
  ::clamp_safety::plc_net* mutable_plc_parameter();
  void set_allocated_plc_parameter(::clamp_safety::plc_net* plc_parameter);
  private:
  const ::clamp_safety::plc_net& _internal_plc_parameter() const;
  ::clamp_safety::plc_net* _internal_mutable_plc_parameter();
  public:
  void unsafe_arena_set_allocated_plc_parameter(
      ::clamp_safety::plc_net* plc_parameter);
  ::clamp_safety::plc_net* unsafe_arena_release_plc_parameter();

  // required .clamp_safety.local_net local_parameter = 3;
  bool has_local_parameter() const;
  private:
  bool _internal_has_local_parameter() const;
  public:
  void clear_local_parameter();
  const ::clamp_safety::local_net& local_parameter() const;
  ::clamp_safety::local_net* release_local_parameter();
  ::clamp_safety::local_net* mutable_local_parameter();
  void set_allocated_local_parameter(::clamp_safety::local_net* local_parameter);
  private:
  const ::clamp_safety::local_net& _internal_local_parameter() const;
  ::clamp_safety::local_net* _internal_mutable_local_parameter();
  public:
  void unsafe_arena_set_allocated_local_parameter(
      ::clamp_safety::local_net* local_parameter);
  ::clamp_safety::local_net* unsafe_arena_release_local_parameter();

  // @@protoc_insertion_point(class_scope:clamp_safety.clamp_parameter)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::clamp_safety::LidarParameter > lidars_;
  ::clamp_safety::plc_net* plc_parameter_;
  ::clamp_safety::local_net* local_parameter_;
  friend struct ::TableStruct_clamp_5fparameter_2eproto;
};
// ===================================================================


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

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

// optional string ip_address = 1 [default = ""];
inline bool lidar_net::_internal_has_ip_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool lidar_net::has_ip_address() const {
  return _internal_has_ip_address();
}
inline void lidar_net::clear_ip_address() {
  ip_address_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& lidar_net::ip_address() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_net.ip_address)
  return _internal_ip_address();
}
inline void lidar_net::set_ip_address(const std::string& value) {
  _internal_set_ip_address(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_net.ip_address)
}
inline std::string* lidar_net::mutable_ip_address() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.lidar_net.ip_address)
  return _internal_mutable_ip_address();
}
inline const std::string& lidar_net::_internal_ip_address() const {
  return ip_address_.Get();
}
inline void lidar_net::_internal_set_ip_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void lidar_net::set_ip_address(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:clamp_safety.lidar_net.ip_address)
}
inline void lidar_net::set_ip_address(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:clamp_safety.lidar_net.ip_address)
}
inline void lidar_net::set_ip_address(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:clamp_safety.lidar_net.ip_address)
}
inline std::string* lidar_net::_internal_mutable_ip_address() {
  _has_bits_[0] |= 0x00000001u;
  return ip_address_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* lidar_net::release_ip_address() {
  // @@protoc_insertion_point(field_release:clamp_safety.lidar_net.ip_address)
  if (!_internal_has_ip_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return ip_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void lidar_net::set_allocated_ip_address(std::string* ip_address) {
  if (ip_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  ip_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip_address,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.lidar_net.ip_address)
}

// optional int32 port = 2 [default = 8000];
inline bool lidar_net::_internal_has_port() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool lidar_net::has_port() const {
  return _internal_has_port();
}
inline void lidar_net::clear_port() {
  port_ = 8000;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 lidar_net::_internal_port() const {
  return port_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 lidar_net::port() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_net.port)
  return _internal_port();
}
inline void lidar_net::_internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  port_ = value;
}
inline void lidar_net::set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_net.port)
}

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

// lidar_box_limit

// optional float dist_limit = 1 [default = 8];
inline bool lidar_box_limit::_internal_has_dist_limit() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool lidar_box_limit::has_dist_limit() const {
  return _internal_has_dist_limit();
}
inline void lidar_box_limit::clear_dist_limit() {
  dist_limit_ = 8;
  _has_bits_[0] &= ~0x00000002u;
}
inline float lidar_box_limit::_internal_dist_limit() const {
  return dist_limit_;
}
inline float lidar_box_limit::dist_limit() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_box_limit.dist_limit)
  return _internal_dist_limit();
}
inline void lidar_box_limit::_internal_set_dist_limit(float value) {
  _has_bits_[0] |= 0x00000002u;
  dist_limit_ = value;
}
inline void lidar_box_limit::set_dist_limit(float value) {
  _internal_set_dist_limit(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_box_limit.dist_limit)
}

// optional float minx = 2 [default = -6];
inline bool lidar_box_limit::_internal_has_minx() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool lidar_box_limit::has_minx() const {
  return _internal_has_minx();
}
inline void lidar_box_limit::clear_minx() {
  minx_ = -6;
  _has_bits_[0] &= ~0x00000004u;
}
inline float lidar_box_limit::_internal_minx() const {
  return minx_;
}
inline float lidar_box_limit::minx() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_box_limit.minx)
  return _internal_minx();
}
inline void lidar_box_limit::_internal_set_minx(float value) {
  _has_bits_[0] |= 0x00000004u;
  minx_ = value;
}
inline void lidar_box_limit::set_minx(float value) {
  _internal_set_minx(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_box_limit.minx)
}

// optional float maxx = 3 [default = -0.2];
inline bool lidar_box_limit::_internal_has_maxx() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool lidar_box_limit::has_maxx() const {
  return _internal_has_maxx();
}
inline void lidar_box_limit::clear_maxx() {
  maxx_ = -0.2f;
  _has_bits_[0] &= ~0x00000008u;
}
inline float lidar_box_limit::_internal_maxx() const {
  return maxx_;
}
inline float lidar_box_limit::maxx() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_box_limit.maxx)
  return _internal_maxx();
}
inline void lidar_box_limit::_internal_set_maxx(float value) {
  _has_bits_[0] |= 0x00000008u;
  maxx_ = value;
}
inline void lidar_box_limit::set_maxx(float value) {
  _internal_set_maxx(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_box_limit.maxx)
}

// optional float miny = 4 [default = -3.5];
inline bool lidar_box_limit::_internal_has_miny() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool lidar_box_limit::has_miny() const {
  return _internal_has_miny();
}
inline void lidar_box_limit::clear_miny() {
  miny_ = -3.5f;
  _has_bits_[0] &= ~0x00000010u;
}
inline float lidar_box_limit::_internal_miny() const {
  return miny_;
}
inline float lidar_box_limit::miny() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_box_limit.miny)
  return _internal_miny();
}
inline void lidar_box_limit::_internal_set_miny(float value) {
  _has_bits_[0] |= 0x00000010u;
  miny_ = value;
}
inline void lidar_box_limit::set_miny(float value) {
  _internal_set_miny(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_box_limit.miny)
}

// optional float maxy = 5 [default = 3.5];
inline bool lidar_box_limit::_internal_has_maxy() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool lidar_box_limit::has_maxy() const {
  return _internal_has_maxy();
}
inline void lidar_box_limit::clear_maxy() {
  maxy_ = 3.5f;
  _has_bits_[0] &= ~0x00000001u;
}
inline float lidar_box_limit::_internal_maxy() const {
  return maxy_;
}
inline float lidar_box_limit::maxy() const {
  // @@protoc_insertion_point(field_get:clamp_safety.lidar_box_limit.maxy)
  return _internal_maxy();
}
inline void lidar_box_limit::_internal_set_maxy(float value) {
  _has_bits_[0] |= 0x00000001u;
  maxy_ = value;
}
inline void lidar_box_limit::set_maxy(float value) {
  _internal_set_maxy(value);
  // @@protoc_insertion_point(field_set:clamp_safety.lidar_box_limit.maxy)
}

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

// LidarParameter

// optional float angle_min = 1 [default = -2.3561945];
inline bool LidarParameter::_internal_has_angle_min() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LidarParameter::has_angle_min() const {
  return _internal_has_angle_min();
}
inline void LidarParameter::clear_angle_min() {
  angle_min_ = -2.3561945f;
  _has_bits_[0] &= ~0x00000010u;
}
inline float LidarParameter::_internal_angle_min() const {
  return angle_min_;
}
inline float LidarParameter::angle_min() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.angle_min)
  return _internal_angle_min();
}
inline void LidarParameter::_internal_set_angle_min(float value) {
  _has_bits_[0] |= 0x00000010u;
  angle_min_ = value;
}
inline void LidarParameter::set_angle_min(float value) {
  _internal_set_angle_min(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.angle_min)
}

// optional float angle_max = 2 [default = 2.3561945];
inline bool LidarParameter::_internal_has_angle_max() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool LidarParameter::has_angle_max() const {
  return _internal_has_angle_max();
}
inline void LidarParameter::clear_angle_max() {
  angle_max_ = 2.3561945f;
  _has_bits_[0] &= ~0x00000020u;
}
inline float LidarParameter::_internal_angle_max() const {
  return angle_max_;
}
inline float LidarParameter::angle_max() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.angle_max)
  return _internal_angle_max();
}
inline void LidarParameter::_internal_set_angle_max(float value) {
  _has_bits_[0] |= 0x00000020u;
  angle_max_ = value;
}
inline void LidarParameter::set_angle_max(float value) {
  _internal_set_angle_max(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.angle_max)
}

// optional float angle_increment = 3 [default = 0.00582];
inline bool LidarParameter::_internal_has_angle_increment() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool LidarParameter::has_angle_increment() const {
  return _internal_has_angle_increment();
}
inline void LidarParameter::clear_angle_increment() {
  angle_increment_ = 0.00582f;
  _has_bits_[0] &= ~0x00000040u;
}
inline float LidarParameter::_internal_angle_increment() const {
  return angle_increment_;
}
inline float LidarParameter::angle_increment() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.angle_increment)
  return _internal_angle_increment();
}
inline void LidarParameter::_internal_set_angle_increment(float value) {
  _has_bits_[0] |= 0x00000040u;
  angle_increment_ = value;
}
inline void LidarParameter::set_angle_increment(float value) {
  _internal_set_angle_increment(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.angle_increment)
}

// optional float time_increment = 4 [default = 6.2e-05];
inline bool LidarParameter::_internal_has_time_increment() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool LidarParameter::has_time_increment() const {
  return _internal_has_time_increment();
}
inline void LidarParameter::clear_time_increment() {
  time_increment_ = 6.2e-05f;
  _has_bits_[0] &= ~0x00000080u;
}
inline float LidarParameter::_internal_time_increment() const {
  return time_increment_;
}
inline float LidarParameter::time_increment() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.time_increment)
  return _internal_time_increment();
}
inline void LidarParameter::_internal_set_time_increment(float value) {
  _has_bits_[0] |= 0x00000080u;
  time_increment_ = value;
}
inline void LidarParameter::set_time_increment(float value) {
  _internal_set_time_increment(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.time_increment)
}

// optional int32 range_min = 5 [default = 0];
inline bool LidarParameter::_internal_has_range_min() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LidarParameter::has_range_min() const {
  return _internal_has_range_min();
}
inline void LidarParameter::clear_range_min() {
  range_min_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LidarParameter::_internal_range_min() const {
  return range_min_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LidarParameter::range_min() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.range_min)
  return _internal_range_min();
}
inline void LidarParameter::_internal_set_range_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  range_min_ = value;
}
inline void LidarParameter::set_range_min(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_range_min(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.range_min)
}

// optional int32 range_max = 6 [default = 30];
inline bool LidarParameter::_internal_has_range_max() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LidarParameter::has_range_max() const {
  return _internal_has_range_max();
}
inline void LidarParameter::clear_range_max() {
  range_max_ = 30;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LidarParameter::_internal_range_max() const {
  return range_max_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LidarParameter::range_max() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.range_max)
  return _internal_range_max();
}
inline void LidarParameter::_internal_set_range_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  range_max_ = value;
}
inline void LidarParameter::set_range_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_range_max(value);
  // @@protoc_insertion_point(field_set:clamp_safety.LidarParameter.range_max)
}

// required .clamp_safety.lidar_net net_config = 7;
inline bool LidarParameter::_internal_has_net_config() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || net_config_ != nullptr);
  return value;
}
inline bool LidarParameter::has_net_config() const {
  return _internal_has_net_config();
}
inline void LidarParameter::clear_net_config() {
  if (net_config_ != nullptr) net_config_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::clamp_safety::lidar_net& LidarParameter::_internal_net_config() const {
  const ::clamp_safety::lidar_net* p = net_config_;
  return p != nullptr ? *p : *reinterpret_cast<const ::clamp_safety::lidar_net*>(
      &::clamp_safety::_lidar_net_default_instance_);
}
inline const ::clamp_safety::lidar_net& LidarParameter::net_config() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.net_config)
  return _internal_net_config();
}
inline void LidarParameter::unsafe_arena_set_allocated_net_config(
    ::clamp_safety::lidar_net* net_config) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(net_config_);
  }
  net_config_ = net_config;
  if (net_config) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clamp_safety.LidarParameter.net_config)
}
inline ::clamp_safety::lidar_net* LidarParameter::release_net_config() {
  _has_bits_[0] &= ~0x00000001u;
  ::clamp_safety::lidar_net* temp = net_config_;
  net_config_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::clamp_safety::lidar_net* LidarParameter::unsafe_arena_release_net_config() {
  // @@protoc_insertion_point(field_release:clamp_safety.LidarParameter.net_config)
  _has_bits_[0] &= ~0x00000001u;
  ::clamp_safety::lidar_net* temp = net_config_;
  net_config_ = nullptr;
  return temp;
}
inline ::clamp_safety::lidar_net* LidarParameter::_internal_mutable_net_config() {
  _has_bits_[0] |= 0x00000001u;
  if (net_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::clamp_safety::lidar_net>(GetArena());
    net_config_ = p;
  }
  return net_config_;
}
inline ::clamp_safety::lidar_net* LidarParameter::mutable_net_config() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.LidarParameter.net_config)
  return _internal_mutable_net_config();
}
inline void LidarParameter::set_allocated_net_config(::clamp_safety::lidar_net* net_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete net_config_;
  }
  if (net_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(net_config);
    if (message_arena != submessage_arena) {
      net_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, net_config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  net_config_ = net_config;
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.LidarParameter.net_config)
}

// required .clamp_safety.lidar_box_limit scan_box_limit = 8;
inline bool LidarParameter::_internal_has_scan_box_limit() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || scan_box_limit_ != nullptr);
  return value;
}
inline bool LidarParameter::has_scan_box_limit() const {
  return _internal_has_scan_box_limit();
}
inline void LidarParameter::clear_scan_box_limit() {
  if (scan_box_limit_ != nullptr) scan_box_limit_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::clamp_safety::lidar_box_limit& LidarParameter::_internal_scan_box_limit() const {
  const ::clamp_safety::lidar_box_limit* p = scan_box_limit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::clamp_safety::lidar_box_limit*>(
      &::clamp_safety::_lidar_box_limit_default_instance_);
}
inline const ::clamp_safety::lidar_box_limit& LidarParameter::scan_box_limit() const {
  // @@protoc_insertion_point(field_get:clamp_safety.LidarParameter.scan_box_limit)
  return _internal_scan_box_limit();
}
inline void LidarParameter::unsafe_arena_set_allocated_scan_box_limit(
    ::clamp_safety::lidar_box_limit* scan_box_limit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scan_box_limit_);
  }
  scan_box_limit_ = scan_box_limit;
  if (scan_box_limit) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clamp_safety.LidarParameter.scan_box_limit)
}
inline ::clamp_safety::lidar_box_limit* LidarParameter::release_scan_box_limit() {
  _has_bits_[0] &= ~0x00000002u;
  ::clamp_safety::lidar_box_limit* temp = scan_box_limit_;
  scan_box_limit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::clamp_safety::lidar_box_limit* LidarParameter::unsafe_arena_release_scan_box_limit() {
  // @@protoc_insertion_point(field_release:clamp_safety.LidarParameter.scan_box_limit)
  _has_bits_[0] &= ~0x00000002u;
  ::clamp_safety::lidar_box_limit* temp = scan_box_limit_;
  scan_box_limit_ = nullptr;
  return temp;
}
inline ::clamp_safety::lidar_box_limit* LidarParameter::_internal_mutable_scan_box_limit() {
  _has_bits_[0] |= 0x00000002u;
  if (scan_box_limit_ == nullptr) {
    auto* p = CreateMaybeMessage<::clamp_safety::lidar_box_limit>(GetArena());
    scan_box_limit_ = p;
  }
  return scan_box_limit_;
}
inline ::clamp_safety::lidar_box_limit* LidarParameter::mutable_scan_box_limit() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.LidarParameter.scan_box_limit)
  return _internal_mutable_scan_box_limit();
}
inline void LidarParameter::set_allocated_scan_box_limit(::clamp_safety::lidar_box_limit* scan_box_limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete scan_box_limit_;
  }
  if (scan_box_limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scan_box_limit);
    if (message_arena != submessage_arena) {
      scan_box_limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, scan_box_limit, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  scan_box_limit_ = scan_box_limit;
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.LidarParameter.scan_box_limit)
}

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

// plc_net

// optional string ip_address = 1 [default = ""];
inline bool plc_net::_internal_has_ip_address() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool plc_net::has_ip_address() const {
  return _internal_has_ip_address();
}
inline void plc_net::clear_ip_address() {
  ip_address_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& plc_net::ip_address() const {
  // @@protoc_insertion_point(field_get:clamp_safety.plc_net.ip_address)
  return _internal_ip_address();
}
inline void plc_net::set_ip_address(const std::string& value) {
  _internal_set_ip_address(value);
  // @@protoc_insertion_point(field_set:clamp_safety.plc_net.ip_address)
}
inline std::string* plc_net::mutable_ip_address() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.plc_net.ip_address)
  return _internal_mutable_ip_address();
}
inline const std::string& plc_net::_internal_ip_address() const {
  return ip_address_.Get();
}
inline void plc_net::_internal_set_ip_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void plc_net::set_ip_address(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:clamp_safety.plc_net.ip_address)
}
inline void plc_net::set_ip_address(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:clamp_safety.plc_net.ip_address)
}
inline void plc_net::set_ip_address(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:clamp_safety.plc_net.ip_address)
}
inline std::string* plc_net::_internal_mutable_ip_address() {
  _has_bits_[0] |= 0x00000001u;
  return ip_address_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* plc_net::release_ip_address() {
  // @@protoc_insertion_point(field_release:clamp_safety.plc_net.ip_address)
  if (!_internal_has_ip_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return ip_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void plc_net::set_allocated_ip_address(std::string* ip_address) {
  if (ip_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  ip_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip_address,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.plc_net.ip_address)
}

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

// local_net

// optional string local_ip = 1 [default = "10.211.0.1"];
inline bool local_net::_internal_has_local_ip() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool local_net::has_local_ip() const {
  return _internal_has_local_ip();
}
inline void local_net::clear_local_ip() {
  local_ip_.ClearToDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& local_net::local_ip() const {
  // @@protoc_insertion_point(field_get:clamp_safety.local_net.local_ip)
  return _internal_local_ip();
}
inline void local_net::set_local_ip(const std::string& value) {
  _internal_set_local_ip(value);
  // @@protoc_insertion_point(field_set:clamp_safety.local_net.local_ip)
}
inline std::string* local_net::mutable_local_ip() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.local_net.local_ip)
  return _internal_mutable_local_ip();
}
inline const std::string& local_net::_internal_local_ip() const {
  return local_ip_.Get();
}
inline void local_net::_internal_set_local_ip(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  local_ip_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), value, GetArena());
}
inline void local_net::set_local_ip(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  local_ip_.Set(
    &::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:clamp_safety.local_net.local_ip)
}
inline void local_net::set_local_ip(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  local_ip_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:clamp_safety.local_net.local_ip)
}
inline void local_net::set_local_ip(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  local_ip_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:clamp_safety.local_net.local_ip)
}
inline std::string* local_net::_internal_mutable_local_ip() {
  _has_bits_[0] |= 0x00000001u;
  return local_ip_.Mutable(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), GetArena());
}
inline std::string* local_net::release_local_ip() {
  // @@protoc_insertion_point(field_release:clamp_safety.local_net.local_ip)
  if (!_internal_has_local_ip()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return local_ip_.ReleaseNonDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), GetArena());
}
inline void local_net::set_allocated_local_ip(std::string* local_ip) {
  if (local_ip != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  local_ip_.SetAllocated(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), local_ip,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.local_net.local_ip)
}

// optional string eth_name = 2 [default = "eth0"];
inline bool local_net::_internal_has_eth_name() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool local_net::has_eth_name() const {
  return _internal_has_eth_name();
}
inline void local_net::clear_eth_name() {
  eth_name_.ClearToDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& local_net::eth_name() const {
  // @@protoc_insertion_point(field_get:clamp_safety.local_net.eth_name)
  return _internal_eth_name();
}
inline void local_net::set_eth_name(const std::string& value) {
  _internal_set_eth_name(value);
  // @@protoc_insertion_point(field_set:clamp_safety.local_net.eth_name)
}
inline std::string* local_net::mutable_eth_name() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.local_net.eth_name)
  return _internal_mutable_eth_name();
}
inline const std::string& local_net::_internal_eth_name() const {
  return eth_name_.Get();
}
inline void local_net::_internal_set_eth_name(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  eth_name_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), value, GetArena());
}
inline void local_net::set_eth_name(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  eth_name_.Set(
    &::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:clamp_safety.local_net.eth_name)
}
inline void local_net::set_eth_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  eth_name_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:clamp_safety.local_net.eth_name)
}
inline void local_net::set_eth_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  eth_name_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:clamp_safety.local_net.eth_name)
}
inline std::string* local_net::_internal_mutable_eth_name() {
  _has_bits_[0] |= 0x00000002u;
  return eth_name_.Mutable(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), GetArena());
}
inline std::string* local_net::release_eth_name() {
  // @@protoc_insertion_point(field_release:clamp_safety.local_net.eth_name)
  if (!_internal_has_eth_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return eth_name_.ReleaseNonDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), GetArena());
}
inline void local_net::set_allocated_eth_name(std::string* eth_name) {
  if (eth_name != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  eth_name_.SetAllocated(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), eth_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.local_net.eth_name)
}

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

// clamp_parameter

// repeated .clamp_safety.LidarParameter lidars = 1;
inline int clamp_parameter::_internal_lidars_size() const {
  return lidars_.size();
}
inline int clamp_parameter::lidars_size() const {
  return _internal_lidars_size();
}
inline void clamp_parameter::clear_lidars() {
  lidars_.Clear();
}
inline ::clamp_safety::LidarParameter* clamp_parameter::mutable_lidars(int index) {
  // @@protoc_insertion_point(field_mutable:clamp_safety.clamp_parameter.lidars)
  return lidars_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::clamp_safety::LidarParameter >*
clamp_parameter::mutable_lidars() {
  // @@protoc_insertion_point(field_mutable_list:clamp_safety.clamp_parameter.lidars)
  return &lidars_;
}
inline const ::clamp_safety::LidarParameter& clamp_parameter::_internal_lidars(int index) const {
  return lidars_.Get(index);
}
inline const ::clamp_safety::LidarParameter& clamp_parameter::lidars(int index) const {
  // @@protoc_insertion_point(field_get:clamp_safety.clamp_parameter.lidars)
  return _internal_lidars(index);
}
inline ::clamp_safety::LidarParameter* clamp_parameter::_internal_add_lidars() {
  return lidars_.Add();
}
inline ::clamp_safety::LidarParameter* clamp_parameter::add_lidars() {
  // @@protoc_insertion_point(field_add:clamp_safety.clamp_parameter.lidars)
  return _internal_add_lidars();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::clamp_safety::LidarParameter >&
clamp_parameter::lidars() const {
  // @@protoc_insertion_point(field_list:clamp_safety.clamp_parameter.lidars)
  return lidars_;
}

// required .clamp_safety.plc_net plc_parameter = 2;
inline bool clamp_parameter::_internal_has_plc_parameter() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || plc_parameter_ != nullptr);
  return value;
}
inline bool clamp_parameter::has_plc_parameter() const {
  return _internal_has_plc_parameter();
}
inline void clamp_parameter::clear_plc_parameter() {
  if (plc_parameter_ != nullptr) plc_parameter_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::clamp_safety::plc_net& clamp_parameter::_internal_plc_parameter() const {
  const ::clamp_safety::plc_net* p = plc_parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::clamp_safety::plc_net*>(
      &::clamp_safety::_plc_net_default_instance_);
}
inline const ::clamp_safety::plc_net& clamp_parameter::plc_parameter() const {
  // @@protoc_insertion_point(field_get:clamp_safety.clamp_parameter.plc_parameter)
  return _internal_plc_parameter();
}
inline void clamp_parameter::unsafe_arena_set_allocated_plc_parameter(
    ::clamp_safety::plc_net* plc_parameter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(plc_parameter_);
  }
  plc_parameter_ = plc_parameter;
  if (plc_parameter) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clamp_safety.clamp_parameter.plc_parameter)
}
inline ::clamp_safety::plc_net* clamp_parameter::release_plc_parameter() {
  _has_bits_[0] &= ~0x00000001u;
  ::clamp_safety::plc_net* temp = plc_parameter_;
  plc_parameter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::clamp_safety::plc_net* clamp_parameter::unsafe_arena_release_plc_parameter() {
  // @@protoc_insertion_point(field_release:clamp_safety.clamp_parameter.plc_parameter)
  _has_bits_[0] &= ~0x00000001u;
  ::clamp_safety::plc_net* temp = plc_parameter_;
  plc_parameter_ = nullptr;
  return temp;
}
inline ::clamp_safety::plc_net* clamp_parameter::_internal_mutable_plc_parameter() {
  _has_bits_[0] |= 0x00000001u;
  if (plc_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::clamp_safety::plc_net>(GetArena());
    plc_parameter_ = p;
  }
  return plc_parameter_;
}
inline ::clamp_safety::plc_net* clamp_parameter::mutable_plc_parameter() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.clamp_parameter.plc_parameter)
  return _internal_mutable_plc_parameter();
}
inline void clamp_parameter::set_allocated_plc_parameter(::clamp_safety::plc_net* plc_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete plc_parameter_;
  }
  if (plc_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(plc_parameter);
    if (message_arena != submessage_arena) {
      plc_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, plc_parameter, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  plc_parameter_ = plc_parameter;
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.clamp_parameter.plc_parameter)
}

// required .clamp_safety.local_net local_parameter = 3;
inline bool clamp_parameter::_internal_has_local_parameter() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || local_parameter_ != nullptr);
  return value;
}
inline bool clamp_parameter::has_local_parameter() const {
  return _internal_has_local_parameter();
}
inline void clamp_parameter::clear_local_parameter() {
  if (local_parameter_ != nullptr) local_parameter_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::clamp_safety::local_net& clamp_parameter::_internal_local_parameter() const {
  const ::clamp_safety::local_net* p = local_parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::clamp_safety::local_net*>(
      &::clamp_safety::_local_net_default_instance_);
}
inline const ::clamp_safety::local_net& clamp_parameter::local_parameter() const {
  // @@protoc_insertion_point(field_get:clamp_safety.clamp_parameter.local_parameter)
  return _internal_local_parameter();
}
inline void clamp_parameter::unsafe_arena_set_allocated_local_parameter(
    ::clamp_safety::local_net* local_parameter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(local_parameter_);
  }
  local_parameter_ = local_parameter;
  if (local_parameter) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:clamp_safety.clamp_parameter.local_parameter)
}
inline ::clamp_safety::local_net* clamp_parameter::release_local_parameter() {
  _has_bits_[0] &= ~0x00000002u;
  ::clamp_safety::local_net* temp = local_parameter_;
  local_parameter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::clamp_safety::local_net* clamp_parameter::unsafe_arena_release_local_parameter() {
  // @@protoc_insertion_point(field_release:clamp_safety.clamp_parameter.local_parameter)
  _has_bits_[0] &= ~0x00000002u;
  ::clamp_safety::local_net* temp = local_parameter_;
  local_parameter_ = nullptr;
  return temp;
}
inline ::clamp_safety::local_net* clamp_parameter::_internal_mutable_local_parameter() {
  _has_bits_[0] |= 0x00000002u;
  if (local_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::clamp_safety::local_net>(GetArena());
    local_parameter_ = p;
  }
  return local_parameter_;
}
inline ::clamp_safety::local_net* clamp_parameter::mutable_local_parameter() {
  // @@protoc_insertion_point(field_mutable:clamp_safety.clamp_parameter.local_parameter)
  return _internal_mutable_local_parameter();
}
inline void clamp_parameter::set_allocated_local_parameter(::clamp_safety::local_net* local_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete local_parameter_;
  }
  if (local_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(local_parameter);
    if (message_arena != submessage_arena) {
      local_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, local_parameter, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  local_parameter_ = local_parameter;
  // @@protoc_insertion_point(field_set_allocated:clamp_safety.clamp_parameter.local_parameter)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace clamp_safety

// @@protoc_insertion_point(global_scope)

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