clamp_safety/clamp_parameter.pb.cc

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

#include "clamp_parameter.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_LidarParameter_clamp_5fparameter_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_box_limit_clamp_5fparameter_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_net_clamp_5fparameter_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_local_net_clamp_5fparameter_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_clamp_5fparameter_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_plc_net_clamp_5fparameter_2eproto;
namespace clamp_safety {
class lidar_netDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<lidar_net> _instance;
} _lidar_net_default_instance_;
class lidar_box_limitDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<lidar_box_limit> _instance;
} _lidar_box_limit_default_instance_;
class LidarParameterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LidarParameter> _instance;
} _LidarParameter_default_instance_;
class plc_netDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<plc_net> _instance;
} _plc_net_default_instance_;
class local_netDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<local_net> _instance;
} _local_net_default_instance_;
class clamp_parameterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<clamp_parameter> _instance;
} _clamp_parameter_default_instance_;
}  // namespace clamp_safety
static void InitDefaultsscc_info_LidarParameter_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::clamp_safety::_LidarParameter_default_instance_;
    new (ptr) ::clamp_safety::LidarParameter();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::LidarParameter::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_LidarParameter_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_LidarParameter_clamp_5fparameter_2eproto}, {
      &scc_info_lidar_net_clamp_5fparameter_2eproto.base,
      &scc_info_lidar_box_limit_clamp_5fparameter_2eproto.base,}};

static void InitDefaultsscc_info_clamp_parameter_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::clamp_safety::_clamp_parameter_default_instance_;
    new (ptr) ::clamp_safety::clamp_parameter();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::clamp_parameter::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_clamp_parameter_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, 0, InitDefaultsscc_info_clamp_parameter_clamp_5fparameter_2eproto}, {
      &scc_info_LidarParameter_clamp_5fparameter_2eproto.base,
      &scc_info_plc_net_clamp_5fparameter_2eproto.base,
      &scc_info_local_net_clamp_5fparameter_2eproto.base,}};

static void InitDefaultsscc_info_lidar_box_limit_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::clamp_safety::_lidar_box_limit_default_instance_;
    new (ptr) ::clamp_safety::lidar_box_limit();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::lidar_box_limit::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_box_limit_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_lidar_box_limit_clamp_5fparameter_2eproto}, {}};

static void InitDefaultsscc_info_lidar_net_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::clamp_safety::_lidar_net_default_instance_;
    new (ptr) ::clamp_safety::lidar_net();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::lidar_net::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_net_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_lidar_net_clamp_5fparameter_2eproto}, {}};

static void InitDefaultsscc_info_local_net_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.DefaultConstruct();
  *::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get_mutable() = std::string("10.211.0.1", 10);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get_mutable());
  ::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.DefaultConstruct();
  *::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get_mutable() = std::string("eth0", 4);
  ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyString(
      ::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get_mutable());
  {
    void* ptr = &::clamp_safety::_local_net_default_instance_;
    new (ptr) ::clamp_safety::local_net();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::local_net::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_local_net_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_local_net_clamp_5fparameter_2eproto}, {}};

static void InitDefaultsscc_info_plc_net_clamp_5fparameter_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::clamp_safety::_plc_net_default_instance_;
    new (ptr) ::clamp_safety::plc_net();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::clamp_safety::plc_net::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_plc_net_clamp_5fparameter_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_plc_net_clamp_5fparameter_2eproto}, {}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_clamp_5fparameter_2eproto[6];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_clamp_5fparameter_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_clamp_5fparameter_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_clamp_5fparameter_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_net, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_net, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_net, ip_address_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_net, port_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, dist_limit_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, minx_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, maxx_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, miny_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::lidar_box_limit, maxy_),
  1,
  2,
  3,
  4,
  0,
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, angle_min_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, angle_max_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, angle_increment_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, time_increment_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, range_min_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, range_max_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, net_config_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::LidarParameter, scan_box_limit_),
  4,
  5,
  6,
  7,
  2,
  3,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::clamp_safety::plc_net, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::plc_net, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::plc_net, ip_address_),
  0,
  PROTOBUF_FIELD_OFFSET(::clamp_safety::local_net, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::local_net, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::local_net, local_ip_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::local_net, eth_name_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::clamp_safety::clamp_parameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::clamp_parameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::clamp_safety::clamp_parameter, lidars_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::clamp_parameter, plc_parameter_),
  PROTOBUF_FIELD_OFFSET(::clamp_safety::clamp_parameter, local_parameter_),
  ~0u,
  0,
  1,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 7, sizeof(::clamp_safety::lidar_net)},
  { 9, 19, sizeof(::clamp_safety::lidar_box_limit)},
  { 24, 37, sizeof(::clamp_safety::LidarParameter)},
  { 45, 51, sizeof(::clamp_safety::plc_net)},
  { 52, 59, sizeof(::clamp_safety::local_net)},
  { 61, 69, sizeof(::clamp_safety::clamp_parameter)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_lidar_net_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_lidar_box_limit_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_LidarParameter_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_plc_net_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_local_net_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::clamp_safety::_clamp_parameter_default_instance_),
};

const char descriptor_table_protodef_clamp_5fparameter_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\025clamp_parameter.proto\022\014clamp_safety\"5\n"
  "\tlidar_net\022\024\n\nip_address\030\001 \001(\t:\000\022\022\n\004port"
  "\030\002 \001(\005:\0048000\"u\n\017lidar_box_limit\022\025\n\ndist_"
  "limit\030\001 \001(\002:\0018\022\020\n\004minx\030\002 \001(\002:\002-6\022\022\n\004maxx"
  "\030\003 \001(\002:\004-0.2\022\022\n\004miny\030\004 \001(\002:\004-3.5\022\021\n\004maxy"
  "\030\005 \001(\002:\0033.5\"\241\002\n\016LidarParameter\022\035\n\tangle_"
  "min\030\001 \001(\002:\n-2.3561945\022\034\n\tangle_max\030\002 \001(\002"
  ":\t2.3561945\022 \n\017angle_increment\030\003 \001(\002:\0070."
  "00582\022\037\n\016time_increment\030\004 \001(\002:\0076.2e-05\022\024"
  "\n\trange_min\030\005 \001(\005:\0010\022\025\n\trange_max\030\006 \001(\005:"
  "\00230\022+\n\nnet_config\030\007 \002(\0132\027.clamp_safety.l"
  "idar_net\0225\n\016scan_box_limit\030\010 \002(\0132\035.clamp"
  "_safety.lidar_box_limit\"\037\n\007plc_net\022\024\n\nip"
  "_address\030\001 \001(\t:\000\"A\n\tlocal_net\022\034\n\010local_i"
  "p\030\001 \001(\t:\n10.211.0.1\022\026\n\010eth_name\030\002 \001(\t:\004e"
  "th0\"\237\001\n\017clamp_parameter\022,\n\006lidars\030\001 \003(\0132"
  "\034.clamp_safety.LidarParameter\022,\n\rplc_par"
  "ameter\030\002 \002(\0132\025.clamp_safety.plc_net\0220\n\017l"
  "ocal_parameter\030\003 \002(\0132\027.clamp_safety.loca"
  "l_net"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_clamp_5fparameter_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_clamp_5fparameter_2eproto_sccs[6] = {
  &scc_info_LidarParameter_clamp_5fparameter_2eproto.base,
  &scc_info_clamp_parameter_clamp_5fparameter_2eproto.base,
  &scc_info_lidar_box_limit_clamp_5fparameter_2eproto.base,
  &scc_info_lidar_net_clamp_5fparameter_2eproto.base,
  &scc_info_local_net_clamp_5fparameter_2eproto.base,
  &scc_info_plc_net_clamp_5fparameter_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_clamp_5fparameter_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_clamp_5fparameter_2eproto = {
  false, false, descriptor_table_protodef_clamp_5fparameter_2eproto, "clamp_parameter.proto", 765,
  &descriptor_table_clamp_5fparameter_2eproto_once, descriptor_table_clamp_5fparameter_2eproto_sccs, descriptor_table_clamp_5fparameter_2eproto_deps, 6, 0,
  schemas, file_default_instances, TableStruct_clamp_5fparameter_2eproto::offsets,
  file_level_metadata_clamp_5fparameter_2eproto, 6, file_level_enum_descriptors_clamp_5fparameter_2eproto, file_level_service_descriptors_clamp_5fparameter_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_clamp_5fparameter_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_clamp_5fparameter_2eproto)), true);
namespace clamp_safety {

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

void lidar_net::InitAsDefaultInstance() {
}
class lidar_net::_Internal {
 public:
  using HasBits = decltype(std::declval<lidar_net>()._has_bits_);
  static void set_has_ip_address(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_port(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

lidar_net::lidar_net(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.lidar_net)
}
lidar_net::lidar_net(const lidar_net& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_ip_address()) {
    ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ip_address(),
      GetArena());
  }
  port_ = from.port_;
  // @@protoc_insertion_point(copy_constructor:clamp_safety.lidar_net)
}

void lidar_net::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_lidar_net_clamp_5fparameter_2eproto.base);
  ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  port_ = 8000;
}

lidar_net::~lidar_net() {
  // @@protoc_insertion_point(destructor:clamp_safety.lidar_net)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void lidar_net::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  ip_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void lidar_net::ArenaDtor(void* object) {
  lidar_net* _this = reinterpret_cast< lidar_net* >(object);
  (void)_this;
}
void lidar_net::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void lidar_net::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const lidar_net& lidar_net::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_lidar_net_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void lidar_net::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.lidar_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ip_address_.ClearNonDefaultToEmpty();
    }
    port_ = 8000;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* lidar_net::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string ip_address = 1 [default = ""];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_ip_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "clamp_safety.lidar_net.ip_address");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 port = 2 [default = 8000];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_port(&has_bits);
          port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* lidar_net::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.lidar_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string ip_address = 1 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_ip_address().data(), static_cast<int>(this->_internal_ip_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "clamp_safety.lidar_net.ip_address");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_ip_address(), target);
  }

  // optional int32 port = 2 [default = 8000];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_port(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.lidar_net)
  return target;
}

size_t lidar_net::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.lidar_net)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string ip_address = 1 [default = ""];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_ip_address());
    }

    // optional int32 port = 2 [default = 8000];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_port());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void lidar_net::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.lidar_net)
  GOOGLE_DCHECK_NE(&from, this);
  const lidar_net* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<lidar_net>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.lidar_net)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.lidar_net)
    MergeFrom(*source);
  }
}

void lidar_net::MergeFrom(const lidar_net& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.lidar_net)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_ip_address(from._internal_ip_address());
    }
    if (cached_has_bits & 0x00000002u) {
      port_ = from.port_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void lidar_net::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.lidar_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void lidar_net::CopyFrom(const lidar_net& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.lidar_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool lidar_net::IsInitialized() const {
  return true;
}

void lidar_net::InternalSwap(lidar_net* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ip_address_.Swap(&other->ip_address_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(port_, other->port_);
}

::PROTOBUF_NAMESPACE_ID::Metadata lidar_net::GetMetadata() const {
  return GetMetadataStatic();
}


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

void lidar_box_limit::InitAsDefaultInstance() {
}
class lidar_box_limit::_Internal {
 public:
  using HasBits = decltype(std::declval<lidar_box_limit>()._has_bits_);
  static void set_has_dist_limit(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_minx(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_maxx(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_miny(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_maxy(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

lidar_box_limit::lidar_box_limit(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.lidar_box_limit)
}
lidar_box_limit::lidar_box_limit(const lidar_box_limit& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&maxy_, &from.maxy_,
    static_cast<size_t>(reinterpret_cast<char*>(&miny_) -
    reinterpret_cast<char*>(&maxy_)) + sizeof(miny_));
  // @@protoc_insertion_point(copy_constructor:clamp_safety.lidar_box_limit)
}

void lidar_box_limit::SharedCtor() {
  maxy_ = 3.5f;
  dist_limit_ = 8;
  minx_ = -6;
  maxx_ = -0.2f;
  miny_ = -3.5f;
}

lidar_box_limit::~lidar_box_limit() {
  // @@protoc_insertion_point(destructor:clamp_safety.lidar_box_limit)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void lidar_box_limit::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void lidar_box_limit::ArenaDtor(void* object) {
  lidar_box_limit* _this = reinterpret_cast< lidar_box_limit* >(object);
  (void)_this;
}
void lidar_box_limit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void lidar_box_limit::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const lidar_box_limit& lidar_box_limit::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_lidar_box_limit_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void lidar_box_limit::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.lidar_box_limit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    maxy_ = 3.5f;
    dist_limit_ = 8;
    minx_ = -6;
    maxx_ = -0.2f;
    miny_ = -3.5f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* lidar_box_limit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional float dist_limit = 1 [default = 8];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_dist_limit(&has_bits);
          dist_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float minx = 2 [default = -6];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_minx(&has_bits);
          minx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float maxx = 3 [default = -0.2];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_maxx(&has_bits);
          maxx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float miny = 4 [default = -3.5];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_miny(&has_bits);
          miny_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float maxy = 5 [default = 3.5];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_maxy(&has_bits);
          maxy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* lidar_box_limit::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.lidar_box_limit)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float dist_limit = 1 [default = 8];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_dist_limit(), target);
  }

  // optional float minx = 2 [default = -6];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_minx(), target);
  }

  // optional float maxx = 3 [default = -0.2];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_maxx(), target);
  }

  // optional float miny = 4 [default = -3.5];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_miny(), target);
  }

  // optional float maxy = 5 [default = 3.5];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_maxy(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.lidar_box_limit)
  return target;
}

size_t lidar_box_limit::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.lidar_box_limit)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional float maxy = 5 [default = 3.5];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 4;
    }

    // optional float dist_limit = 1 [default = 8];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

    // optional float minx = 2 [default = -6];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 4;
    }

    // optional float maxx = 3 [default = -0.2];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 4;
    }

    // optional float miny = 4 [default = -3.5];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 4;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void lidar_box_limit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.lidar_box_limit)
  GOOGLE_DCHECK_NE(&from, this);
  const lidar_box_limit* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<lidar_box_limit>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.lidar_box_limit)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.lidar_box_limit)
    MergeFrom(*source);
  }
}

void lidar_box_limit::MergeFrom(const lidar_box_limit& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.lidar_box_limit)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      maxy_ = from.maxy_;
    }
    if (cached_has_bits & 0x00000002u) {
      dist_limit_ = from.dist_limit_;
    }
    if (cached_has_bits & 0x00000004u) {
      minx_ = from.minx_;
    }
    if (cached_has_bits & 0x00000008u) {
      maxx_ = from.maxx_;
    }
    if (cached_has_bits & 0x00000010u) {
      miny_ = from.miny_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void lidar_box_limit::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.lidar_box_limit)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void lidar_box_limit::CopyFrom(const lidar_box_limit& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.lidar_box_limit)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool lidar_box_limit::IsInitialized() const {
  return true;
}

void lidar_box_limit::InternalSwap(lidar_box_limit* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(maxy_, other->maxy_);
  swap(dist_limit_, other->dist_limit_);
  swap(minx_, other->minx_);
  swap(maxx_, other->maxx_);
  swap(miny_, other->miny_);
}

::PROTOBUF_NAMESPACE_ID::Metadata lidar_box_limit::GetMetadata() const {
  return GetMetadataStatic();
}


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

void LidarParameter::InitAsDefaultInstance() {
  ::clamp_safety::_LidarParameter_default_instance_._instance.get_mutable()->net_config_ = const_cast< ::clamp_safety::lidar_net*>(
      ::clamp_safety::lidar_net::internal_default_instance());
  ::clamp_safety::_LidarParameter_default_instance_._instance.get_mutable()->scan_box_limit_ = const_cast< ::clamp_safety::lidar_box_limit*>(
      ::clamp_safety::lidar_box_limit::internal_default_instance());
}
class LidarParameter::_Internal {
 public:
  using HasBits = decltype(std::declval<LidarParameter>()._has_bits_);
  static void set_has_angle_min(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_angle_max(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_angle_increment(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_time_increment(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_range_min(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_range_max(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::clamp_safety::lidar_net& net_config(const LidarParameter* msg);
  static void set_has_net_config(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::clamp_safety::lidar_box_limit& scan_box_limit(const LidarParameter* msg);
  static void set_has_scan_box_limit(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

const ::clamp_safety::lidar_net&
LidarParameter::_Internal::net_config(const LidarParameter* msg) {
  return *msg->net_config_;
}
const ::clamp_safety::lidar_box_limit&
LidarParameter::_Internal::scan_box_limit(const LidarParameter* msg) {
  return *msg->scan_box_limit_;
}
LidarParameter::LidarParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.LidarParameter)
}
LidarParameter::LidarParameter(const LidarParameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_net_config()) {
    net_config_ = new ::clamp_safety::lidar_net(*from.net_config_);
  } else {
    net_config_ = nullptr;
  }
  if (from._internal_has_scan_box_limit()) {
    scan_box_limit_ = new ::clamp_safety::lidar_box_limit(*from.scan_box_limit_);
  } else {
    scan_box_limit_ = nullptr;
  }
  ::memcpy(&range_min_, &from.range_min_,
    static_cast<size_t>(reinterpret_cast<char*>(&time_increment_) -
    reinterpret_cast<char*>(&range_min_)) + sizeof(time_increment_));
  // @@protoc_insertion_point(copy_constructor:clamp_safety.LidarParameter)
}

void LidarParameter::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LidarParameter_clamp_5fparameter_2eproto.base);
  ::memset(&net_config_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&range_min_) -
      reinterpret_cast<char*>(&net_config_)) + sizeof(range_min_));
  range_max_ = 30;
  angle_min_ = -2.3561945f;
  angle_max_ = 2.3561945f;
  angle_increment_ = 0.00582f;
  time_increment_ = 6.2e-05f;
}

LidarParameter::~LidarParameter() {
  // @@protoc_insertion_point(destructor:clamp_safety.LidarParameter)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void LidarParameter::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete net_config_;
  if (this != internal_default_instance()) delete scan_box_limit_;
}

void LidarParameter::ArenaDtor(void* object) {
  LidarParameter* _this = reinterpret_cast< LidarParameter* >(object);
  (void)_this;
}
void LidarParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LidarParameter::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const LidarParameter& LidarParameter::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LidarParameter_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void LidarParameter::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.LidarParameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(net_config_ != nullptr);
      net_config_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(scan_box_limit_ != nullptr);
      scan_box_limit_->Clear();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    range_min_ = 0;
    range_max_ = 30;
    angle_min_ = -2.3561945f;
    angle_max_ = 2.3561945f;
    angle_increment_ = 0.00582f;
    time_increment_ = 6.2e-05f;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LidarParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional float angle_min = 1 [default = -2.3561945];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_angle_min(&has_bits);
          angle_min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float angle_max = 2 [default = 2.3561945];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_angle_max(&has_bits);
          angle_max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float angle_increment = 3 [default = 0.00582];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_angle_increment(&has_bits);
          angle_increment_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional float time_increment = 4 [default = 6.2e-05];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_time_increment(&has_bits);
          time_increment_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional int32 range_min = 5 [default = 0];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_range_min(&has_bits);
          range_min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 range_max = 6 [default = 30];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_range_max(&has_bits);
          range_max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .clamp_safety.lidar_net net_config = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_net_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .clamp_safety.lidar_box_limit scan_box_limit = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_scan_box_limit(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* LidarParameter::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.LidarParameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float angle_min = 1 [default = -2.3561945];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_angle_min(), target);
  }

  // optional float angle_max = 2 [default = 2.3561945];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_angle_max(), target);
  }

  // optional float angle_increment = 3 [default = 0.00582];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_angle_increment(), target);
  }

  // optional float time_increment = 4 [default = 6.2e-05];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_time_increment(), target);
  }

  // optional int32 range_min = 5 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_range_min(), target);
  }

  // optional int32 range_max = 6 [default = 30];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_range_max(), target);
  }

  // required .clamp_safety.lidar_net net_config = 7;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::net_config(this), target, stream);
  }

  // required .clamp_safety.lidar_box_limit scan_box_limit = 8;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::scan_box_limit(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.LidarParameter)
  return target;
}

size_t LidarParameter::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:clamp_safety.LidarParameter)
  size_t total_size = 0;

  if (_internal_has_net_config()) {
    // required .clamp_safety.lidar_net net_config = 7;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *net_config_);
  }

  if (_internal_has_scan_box_limit()) {
    // required .clamp_safety.lidar_box_limit scan_box_limit = 8;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *scan_box_limit_);
  }

  return total_size;
}
size_t LidarParameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.LidarParameter)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .clamp_safety.lidar_net net_config = 7;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *net_config_);

    // required .clamp_safety.lidar_box_limit scan_box_limit = 8;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *scan_box_limit_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000fcu) {
    // optional int32 range_min = 5 [default = 0];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_range_min());
    }

    // optional int32 range_max = 6 [default = 30];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_range_max());
    }

    // optional float angle_min = 1 [default = -2.3561945];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 4;
    }

    // optional float angle_max = 2 [default = 2.3561945];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 4;
    }

    // optional float angle_increment = 3 [default = 0.00582];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 4;
    }

    // optional float time_increment = 4 [default = 6.2e-05];
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 4;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LidarParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.LidarParameter)
  GOOGLE_DCHECK_NE(&from, this);
  const LidarParameter* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LidarParameter>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.LidarParameter)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.LidarParameter)
    MergeFrom(*source);
  }
}

void LidarParameter::MergeFrom(const LidarParameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.LidarParameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_net_config()->::clamp_safety::lidar_net::MergeFrom(from._internal_net_config());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_scan_box_limit()->::clamp_safety::lidar_box_limit::MergeFrom(from._internal_scan_box_limit());
    }
    if (cached_has_bits & 0x00000004u) {
      range_min_ = from.range_min_;
    }
    if (cached_has_bits & 0x00000008u) {
      range_max_ = from.range_max_;
    }
    if (cached_has_bits & 0x00000010u) {
      angle_min_ = from.angle_min_;
    }
    if (cached_has_bits & 0x00000020u) {
      angle_max_ = from.angle_max_;
    }
    if (cached_has_bits & 0x00000040u) {
      angle_increment_ = from.angle_increment_;
    }
    if (cached_has_bits & 0x00000080u) {
      time_increment_ = from.time_increment_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LidarParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.LidarParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LidarParameter::CopyFrom(const LidarParameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.LidarParameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LidarParameter::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void LidarParameter::InternalSwap(LidarParameter* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LidarParameter, range_min_)
      + sizeof(LidarParameter::range_min_)
      - PROTOBUF_FIELD_OFFSET(LidarParameter, net_config_)>(
          reinterpret_cast<char*>(&net_config_),
          reinterpret_cast<char*>(&other->net_config_));
  swap(range_max_, other->range_max_);
  swap(angle_min_, other->angle_min_);
  swap(angle_max_, other->angle_max_);
  swap(angle_increment_, other->angle_increment_);
  swap(time_increment_, other->time_increment_);
}

::PROTOBUF_NAMESPACE_ID::Metadata LidarParameter::GetMetadata() const {
  return GetMetadataStatic();
}


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

void plc_net::InitAsDefaultInstance() {
}
class plc_net::_Internal {
 public:
  using HasBits = decltype(std::declval<plc_net>()._has_bits_);
  static void set_has_ip_address(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

plc_net::plc_net(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.plc_net)
}
plc_net::plc_net(const plc_net& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_ip_address()) {
    ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ip_address(),
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:clamp_safety.plc_net)
}

void plc_net::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_plc_net_clamp_5fparameter_2eproto.base);
  ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

plc_net::~plc_net() {
  // @@protoc_insertion_point(destructor:clamp_safety.plc_net)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void plc_net::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  ip_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void plc_net::ArenaDtor(void* object) {
  plc_net* _this = reinterpret_cast< plc_net* >(object);
  (void)_this;
}
void plc_net::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void plc_net::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const plc_net& plc_net::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_plc_net_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void plc_net::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.plc_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ip_address_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* plc_net::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string ip_address = 1 [default = ""];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_ip_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "clamp_safety.plc_net.ip_address");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* plc_net::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.plc_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string ip_address = 1 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_ip_address().data(), static_cast<int>(this->_internal_ip_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "clamp_safety.plc_net.ip_address");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_ip_address(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.plc_net)
  return target;
}

size_t plc_net::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.plc_net)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string ip_address = 1 [default = ""];
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_ip_address());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void plc_net::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.plc_net)
  GOOGLE_DCHECK_NE(&from, this);
  const plc_net* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<plc_net>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.plc_net)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.plc_net)
    MergeFrom(*source);
  }
}

void plc_net::MergeFrom(const plc_net& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.plc_net)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_ip_address()) {
    _internal_set_ip_address(from._internal_ip_address());
  }
}

void plc_net::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.plc_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void plc_net::CopyFrom(const plc_net& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.plc_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool plc_net::IsInitialized() const {
  return true;
}

void plc_net::InternalSwap(plc_net* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ip_address_.Swap(&other->ip_address_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata plc_net::GetMetadata() const {
  return GetMetadataStatic();
}


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

void local_net::InitAsDefaultInstance() {
}
class local_net::_Internal {
 public:
  using HasBits = decltype(std::declval<local_net>()._has_bits_);
  static void set_has_local_ip(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_eth_name(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> local_net::_i_give_permission_to_break_this_code_default_local_ip_;
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> local_net::_i_give_permission_to_break_this_code_default_eth_name_;
local_net::local_net(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.local_net)
}
local_net::local_net(const local_net& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  local_ip_.UnsafeSetDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get());
  if (from._internal_has_local_ip()) {
    local_ip_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), from._internal_local_ip(),
      GetArena());
  }
  eth_name_.UnsafeSetDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get());
  if (from._internal_has_eth_name()) {
    eth_name_.Set(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), from._internal_eth_name(),
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:clamp_safety.local_net)
}

void local_net::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_local_net_clamp_5fparameter_2eproto.base);
  local_ip_.UnsafeSetDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get());
  eth_name_.UnsafeSetDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get());
}

local_net::~local_net() {
  // @@protoc_insertion_point(destructor:clamp_safety.local_net)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void local_net::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  local_ip_.DestroyNoArena(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get());
  eth_name_.DestroyNoArena(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get());
}

void local_net::ArenaDtor(void* object) {
  local_net* _this = reinterpret_cast< local_net* >(object);
  (void)_this;
}
void local_net::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void local_net::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const local_net& local_net::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_local_net_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void local_net::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.local_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      local_ip_.ClearToDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), GetArena());
    }
    if (cached_has_bits & 0x00000002u) {
      eth_name_.ClearToDefault(&::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), GetArena());
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* local_net::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string local_ip = 1 [default = "10.211.0.1"];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_local_ip();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "clamp_safety.local_net.local_ip");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string eth_name = 2 [default = "eth0"];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_eth_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "clamp_safety.local_net.eth_name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* local_net::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.local_net)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string local_ip = 1 [default = "10.211.0.1"];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_local_ip().data(), static_cast<int>(this->_internal_local_ip().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "clamp_safety.local_net.local_ip");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_local_ip(), target);
  }

  // optional string eth_name = 2 [default = "eth0"];
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_eth_name().data(), static_cast<int>(this->_internal_eth_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "clamp_safety.local_net.eth_name");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_eth_name(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.local_net)
  return target;
}

size_t local_net::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.local_net)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string local_ip = 1 [default = "10.211.0.1"];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_local_ip());
    }

    // optional string eth_name = 2 [default = "eth0"];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_eth_name());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void local_net::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.local_net)
  GOOGLE_DCHECK_NE(&from, this);
  const local_net* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<local_net>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.local_net)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.local_net)
    MergeFrom(*source);
  }
}

void local_net::MergeFrom(const local_net& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.local_net)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_local_ip(from._internal_local_ip());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_eth_name(from._internal_eth_name());
    }
  }
}

void local_net::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.local_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void local_net::CopyFrom(const local_net& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.local_net)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool local_net::IsInitialized() const {
  return true;
}

void local_net::InternalSwap(local_net* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  local_ip_.Swap(&other->local_ip_, &::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_local_ip_.get(), GetArena());
  eth_name_.Swap(&other->eth_name_, &::clamp_safety::local_net::_i_give_permission_to_break_this_code_default_eth_name_.get(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata local_net::GetMetadata() const {
  return GetMetadataStatic();
}


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

void clamp_parameter::InitAsDefaultInstance() {
  ::clamp_safety::_clamp_parameter_default_instance_._instance.get_mutable()->plc_parameter_ = const_cast< ::clamp_safety::plc_net*>(
      ::clamp_safety::plc_net::internal_default_instance());
  ::clamp_safety::_clamp_parameter_default_instance_._instance.get_mutable()->local_parameter_ = const_cast< ::clamp_safety::local_net*>(
      ::clamp_safety::local_net::internal_default_instance());
}
class clamp_parameter::_Internal {
 public:
  using HasBits = decltype(std::declval<clamp_parameter>()._has_bits_);
  static const ::clamp_safety::plc_net& plc_parameter(const clamp_parameter* msg);
  static void set_has_plc_parameter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::clamp_safety::local_net& local_parameter(const clamp_parameter* msg);
  static void set_has_local_parameter(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

const ::clamp_safety::plc_net&
clamp_parameter::_Internal::plc_parameter(const clamp_parameter* msg) {
  return *msg->plc_parameter_;
}
const ::clamp_safety::local_net&
clamp_parameter::_Internal::local_parameter(const clamp_parameter* msg) {
  return *msg->local_parameter_;
}
clamp_parameter::clamp_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  lidars_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:clamp_safety.clamp_parameter)
}
clamp_parameter::clamp_parameter(const clamp_parameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      lidars_(from.lidars_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_plc_parameter()) {
    plc_parameter_ = new ::clamp_safety::plc_net(*from.plc_parameter_);
  } else {
    plc_parameter_ = nullptr;
  }
  if (from._internal_has_local_parameter()) {
    local_parameter_ = new ::clamp_safety::local_net(*from.local_parameter_);
  } else {
    local_parameter_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:clamp_safety.clamp_parameter)
}

void clamp_parameter::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_clamp_parameter_clamp_5fparameter_2eproto.base);
  ::memset(&plc_parameter_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&local_parameter_) -
      reinterpret_cast<char*>(&plc_parameter_)) + sizeof(local_parameter_));
}

clamp_parameter::~clamp_parameter() {
  // @@protoc_insertion_point(destructor:clamp_safety.clamp_parameter)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void clamp_parameter::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete plc_parameter_;
  if (this != internal_default_instance()) delete local_parameter_;
}

void clamp_parameter::ArenaDtor(void* object) {
  clamp_parameter* _this = reinterpret_cast< clamp_parameter* >(object);
  (void)_this;
}
void clamp_parameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void clamp_parameter::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const clamp_parameter& clamp_parameter::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_clamp_parameter_clamp_5fparameter_2eproto.base);
  return *internal_default_instance();
}


void clamp_parameter::Clear() {
// @@protoc_insertion_point(message_clear_start:clamp_safety.clamp_parameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  lidars_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(plc_parameter_ != nullptr);
      plc_parameter_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(local_parameter_ != nullptr);
      local_parameter_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* clamp_parameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .clamp_safety.LidarParameter lidars = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_lidars(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // required .clamp_safety.plc_net plc_parameter = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_plc_parameter(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .clamp_safety.local_net local_parameter = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_local_parameter(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* clamp_parameter::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:clamp_safety.clamp_parameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .clamp_safety.LidarParameter lidars = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_lidars_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_lidars(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // required .clamp_safety.plc_net plc_parameter = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::plc_parameter(this), target, stream);
  }

  // required .clamp_safety.local_net local_parameter = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::local_parameter(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:clamp_safety.clamp_parameter)
  return target;
}

size_t clamp_parameter::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:clamp_safety.clamp_parameter)
  size_t total_size = 0;

  if (_internal_has_plc_parameter()) {
    // required .clamp_safety.plc_net plc_parameter = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *plc_parameter_);
  }

  if (_internal_has_local_parameter()) {
    // required .clamp_safety.local_net local_parameter = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *local_parameter_);
  }

  return total_size;
}
size_t clamp_parameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:clamp_safety.clamp_parameter)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .clamp_safety.plc_net plc_parameter = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *plc_parameter_);

    // required .clamp_safety.local_net local_parameter = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *local_parameter_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .clamp_safety.LidarParameter lidars = 1;
  total_size += 1UL * this->_internal_lidars_size();
  for (const auto& msg : this->lidars_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void clamp_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:clamp_safety.clamp_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  const clamp_parameter* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<clamp_parameter>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:clamp_safety.clamp_parameter)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:clamp_safety.clamp_parameter)
    MergeFrom(*source);
  }
}

void clamp_parameter::MergeFrom(const clamp_parameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:clamp_safety.clamp_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  lidars_.MergeFrom(from.lidars_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_plc_parameter()->::clamp_safety::plc_net::MergeFrom(from._internal_plc_parameter());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_local_parameter()->::clamp_safety::local_net::MergeFrom(from._internal_local_parameter());
    }
  }
}

void clamp_parameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:clamp_safety.clamp_parameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void clamp_parameter::CopyFrom(const clamp_parameter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:clamp_safety.clamp_parameter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool clamp_parameter::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(lidars_)) return false;
  return true;
}

void clamp_parameter::InternalSwap(clamp_parameter* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  lidars_.InternalSwap(&other->lidars_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(clamp_parameter, local_parameter_)
      + sizeof(clamp_parameter::local_parameter_)
      - PROTOBUF_FIELD_OFFSET(clamp_parameter, plc_parameter_)>(
          reinterpret_cast<char*>(&plc_parameter_),
          reinterpret_cast<char*>(&other->plc_parameter_));
}

::PROTOBUF_NAMESPACE_ID::Metadata clamp_parameter::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace clamp_safety
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::clamp_safety::lidar_net* Arena::CreateMaybeMessage< ::clamp_safety::lidar_net >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::lidar_net >(arena);
}
template<> PROTOBUF_NOINLINE ::clamp_safety::lidar_box_limit* Arena::CreateMaybeMessage< ::clamp_safety::lidar_box_limit >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::lidar_box_limit >(arena);
}
template<> PROTOBUF_NOINLINE ::clamp_safety::LidarParameter* Arena::CreateMaybeMessage< ::clamp_safety::LidarParameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::LidarParameter >(arena);
}
template<> PROTOBUF_NOINLINE ::clamp_safety::plc_net* Arena::CreateMaybeMessage< ::clamp_safety::plc_net >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::plc_net >(arena);
}
template<> PROTOBUF_NOINLINE ::clamp_safety::local_net* Arena::CreateMaybeMessage< ::clamp_safety::local_net >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::local_net >(arena);
}
template<> PROTOBUF_NOINLINE ::clamp_safety::clamp_parameter* Arena::CreateMaybeMessage< ::clamp_safety::clamp_parameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::clamp_safety::clamp_parameter >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>