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

#ifndef GOOGLE_PROTOBUF_INCLUDED_setting_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_setting_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_setting_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_setting_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[5]
    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_setting_2eproto;
namespace shutter {
class box_param;
class box_paramDefaultTypeInternal;
extern box_paramDefaultTypeInternal _box_param_default_instance_;
class lidar_parameter;
class lidar_parameterDefaultTypeInternal;
extern lidar_parameterDefaultTypeInternal _lidar_parameter_default_instance_;
class plc_param;
class plc_paramDefaultTypeInternal;
extern plc_paramDefaultTypeInternal _plc_param_default_instance_;
class setting_parameter;
class setting_parameterDefaultTypeInternal;
extern setting_parameterDefaultTypeInternal _setting_parameter_default_instance_;
class shutter_param;
class shutter_paramDefaultTypeInternal;
extern shutter_paramDefaultTypeInternal _shutter_param_default_instance_;
}  // namespace shutter
PROTOBUF_NAMESPACE_OPEN
template<> ::shutter::box_param* Arena::CreateMaybeMessage<::shutter::box_param>(Arena*);
template<> ::shutter::lidar_parameter* Arena::CreateMaybeMessage<::shutter::lidar_parameter>(Arena*);
template<> ::shutter::plc_param* Arena::CreateMaybeMessage<::shutter::plc_param>(Arena*);
template<> ::shutter::setting_parameter* Arena::CreateMaybeMessage<::shutter::setting_parameter>(Arena*);
template<> ::shutter::shutter_param* Arena::CreateMaybeMessage<::shutter::shutter_param>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace shutter {

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

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

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

  inline lidar_parameter& operator=(const lidar_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline lidar_parameter& operator=(lidar_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 lidar_parameter& default_instance();

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

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

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

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

  lidar_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<lidar_parameter>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const lidar_parameter& from);
  void MergeFrom(const lidar_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(lidar_parameter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "shutter.lidar_parameter";
  }
  protected:
  explicit lidar_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_setting_2eproto);
    return ::descriptor_table_setting_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSncodeFieldNumber = 1,
    kRFieldNumber = 2,
    kPFieldNumber = 3,
    kYFieldNumber = 4,
    kTxFieldNumber = 5,
    kTyFieldNumber = 6,
    kTzFieldNumber = 7,
    kFpsFieldNumber = 8,
  };
  // optional string sncode = 1;
  bool has_sncode() const;
  private:
  bool _internal_has_sncode() const;
  public:
  void clear_sncode();
  const std::string& sncode() const;
  void set_sncode(const std::string& value);
  void set_sncode(std::string&& value);
  void set_sncode(const char* value);
  void set_sncode(const char* value, size_t size);
  std::string* mutable_sncode();
  std::string* release_sncode();
  void set_allocated_sncode(std::string* sncode);
  private:
  const std::string& _internal_sncode() const;
  void _internal_set_sncode(const std::string& value);
  std::string* _internal_mutable_sncode();
  public:

  // optional double r = 2 [default = 0];
  bool has_r() const;
  private:
  bool _internal_has_r() const;
  public:
  void clear_r();
  double r() const;
  void set_r(double value);
  private:
  double _internal_r() const;
  void _internal_set_r(double value);
  public:

  // optional double p = 3 [default = 0];
  bool has_p() const;
  private:
  bool _internal_has_p() const;
  public:
  void clear_p();
  double p() const;
  void set_p(double value);
  private:
  double _internal_p() const;
  void _internal_set_p(double value);
  public:

  // optional double y = 4 [default = 0];
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  double y() const;
  void set_y(double value);
  private:
  double _internal_y() const;
  void _internal_set_y(double value);
  public:

  // optional double tx = 5 [default = 1];
  bool has_tx() const;
  private:
  bool _internal_has_tx() const;
  public:
  void clear_tx();
  double tx() const;
  void set_tx(double value);
  private:
  double _internal_tx() const;
  void _internal_set_tx(double value);
  public:

  // optional double ty = 6 [default = 1];
  bool has_ty() const;
  private:
  bool _internal_has_ty() const;
  public:
  void clear_ty();
  double ty() const;
  void set_ty(double value);
  private:
  double _internal_ty() const;
  void _internal_set_ty(double value);
  public:

  // optional double tz = 7 [default = 1];
  bool has_tz() const;
  private:
  bool _internal_has_tz() const;
  public:
  void clear_tz();
  double tz() const;
  void set_tz(double value);
  private:
  double _internal_tz() const;
  void _internal_set_tz(double value);
  public:

  // optional double fps = 8 [default = 10];
  bool has_fps() const;
  private:
  bool _internal_has_fps() const;
  public:
  void clear_fps();
  double fps() const;
  void set_fps(double value);
  private:
  double _internal_fps() const;
  void _internal_set_fps(double value);
  public:

  // @@protoc_insertion_point(class_scope:shutter.lidar_parameter)
 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 sncode_;
  double r_;
  double p_;
  double y_;
  double tx_;
  double ty_;
  double tz_;
  double fps_;
  friend struct ::TableStruct_setting_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline box_param& operator=(const box_param& from) {
    CopyFrom(from);
    return *this;
  }
  inline box_param& operator=(box_param&& 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 box_param& default_instance();

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

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

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

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

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

  public:

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

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

  enum : int {
    kMinxFieldNumber = 1,
    kMaxxFieldNumber = 2,
    kMinyFieldNumber = 3,
    kMaxyFieldNumber = 4,
    kMinzFieldNumber = 5,
    kMaxzFieldNumber = 6,
  };
  // optional double minx = 1;
  bool has_minx() const;
  private:
  bool _internal_has_minx() const;
  public:
  void clear_minx();
  double minx() const;
  void set_minx(double value);
  private:
  double _internal_minx() const;
  void _internal_set_minx(double value);
  public:

  // optional double maxx = 2;
  bool has_maxx() const;
  private:
  bool _internal_has_maxx() const;
  public:
  void clear_maxx();
  double maxx() const;
  void set_maxx(double value);
  private:
  double _internal_maxx() const;
  void _internal_set_maxx(double value);
  public:

  // optional double miny = 3;
  bool has_miny() const;
  private:
  bool _internal_has_miny() const;
  public:
  void clear_miny();
  double miny() const;
  void set_miny(double value);
  private:
  double _internal_miny() const;
  void _internal_set_miny(double value);
  public:

  // optional double maxy = 4;
  bool has_maxy() const;
  private:
  bool _internal_has_maxy() const;
  public:
  void clear_maxy();
  double maxy() const;
  void set_maxy(double value);
  private:
  double _internal_maxy() const;
  void _internal_set_maxy(double value);
  public:

  // optional double minz = 5;
  bool has_minz() const;
  private:
  bool _internal_has_minz() const;
  public:
  void clear_minz();
  double minz() const;
  void set_minz(double value);
  private:
  double _internal_minz() const;
  void _internal_set_minz(double value);
  public:

  // optional double maxz = 6;
  bool has_maxz() const;
  private:
  bool _internal_has_maxz() const;
  public:
  void clear_maxz();
  double maxz() const;
  void set_maxz(double value);
  private:
  double _internal_maxz() const;
  void _internal_set_maxz(double value);
  public:

  // @@protoc_insertion_point(class_scope:shutter.box_param)
 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_;
  double minx_;
  double maxx_;
  double miny_;
  double maxy_;
  double minz_;
  double maxz_;
  friend struct ::TableStruct_setting_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline plc_param& operator=(const plc_param& from) {
    CopyFrom(from);
    return *this;
  }
  inline plc_param& operator=(plc_param&& 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_param& default_instance();

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

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

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

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

  plc_param* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<plc_param>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const plc_param& from);
  void MergeFrom(const plc_param& 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_param* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "shutter.plc_param";
  }
  protected:
  explicit plc_param(::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_setting_2eproto);
    return ::descriptor_table_setting_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIpFieldNumber = 1,
    kDbnumberFieldNumber = 2,
    kStartIdFieldNumber = 3,
  };
  // required string ip = 1;
  bool has_ip() const;
  private:
  bool _internal_has_ip() const;
  public:
  void clear_ip();
  const std::string& ip() const;
  void set_ip(const std::string& value);
  void set_ip(std::string&& value);
  void set_ip(const char* value);
  void set_ip(const char* value, size_t size);
  std::string* mutable_ip();
  std::string* release_ip();
  void set_allocated_ip(std::string* ip);
  private:
  const std::string& _internal_ip() const;
  void _internal_set_ip(const std::string& value);
  std::string* _internal_mutable_ip();
  public:

  // required int32 dbnumber = 2;
  bool has_dbnumber() const;
  private:
  bool _internal_has_dbnumber() const;
  public:
  void clear_dbnumber();
  ::PROTOBUF_NAMESPACE_ID::int32 dbnumber() const;
  void set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_dbnumber() const;
  void _internal_set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 start_id = 3 [default = 0];
  bool has_start_id() const;
  private:
  bool _internal_has_start_id() const;
  public:
  void clear_start_id();
  ::PROTOBUF_NAMESPACE_ID::int32 start_id() const;
  void set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_start_id() const;
  void _internal_set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:shutter.plc_param)
 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::internal::ArenaStringPtr ip_;
  ::PROTOBUF_NAMESPACE_ID::int32 dbnumber_;
  ::PROTOBUF_NAMESPACE_ID::int32 start_id_;
  friend struct ::TableStruct_setting_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline shutter_param& operator=(const shutter_param& from) {
    CopyFrom(from);
    return *this;
  }
  inline shutter_param& operator=(shutter_param&& 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 shutter_param& default_instance();

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

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

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

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

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

  public:

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

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

  enum : int {
    kLidarsFieldNumber = 1,
    kBoxFieldNumber = 2,
    kVerifyBox1FieldNumber = 3,
    kVerifyBox2FieldNumber = 4,
  };
  // repeated .shutter.lidar_parameter lidars = 1;
  int lidars_size() const;
  private:
  int _internal_lidars_size() const;
  public:
  void clear_lidars();
  ::shutter::lidar_parameter* mutable_lidars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::shutter::lidar_parameter >*
      mutable_lidars();
  private:
  const ::shutter::lidar_parameter& _internal_lidars(int index) const;
  ::shutter::lidar_parameter* _internal_add_lidars();
  public:
  const ::shutter::lidar_parameter& lidars(int index) const;
  ::shutter::lidar_parameter* add_lidars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::shutter::lidar_parameter >&
      lidars() const;

  // optional .shutter.box_param box = 2;
  bool has_box() const;
  private:
  bool _internal_has_box() const;
  public:
  void clear_box();
  const ::shutter::box_param& box() const;
  ::shutter::box_param* release_box();
  ::shutter::box_param* mutable_box();
  void set_allocated_box(::shutter::box_param* box);
  private:
  const ::shutter::box_param& _internal_box() const;
  ::shutter::box_param* _internal_mutable_box();
  public:
  void unsafe_arena_set_allocated_box(
      ::shutter::box_param* box);
  ::shutter::box_param* unsafe_arena_release_box();

  // optional .shutter.box_param verify_box1 = 3;
  bool has_verify_box1() const;
  private:
  bool _internal_has_verify_box1() const;
  public:
  void clear_verify_box1();
  const ::shutter::box_param& verify_box1() const;
  ::shutter::box_param* release_verify_box1();
  ::shutter::box_param* mutable_verify_box1();
  void set_allocated_verify_box1(::shutter::box_param* verify_box1);
  private:
  const ::shutter::box_param& _internal_verify_box1() const;
  ::shutter::box_param* _internal_mutable_verify_box1();
  public:
  void unsafe_arena_set_allocated_verify_box1(
      ::shutter::box_param* verify_box1);
  ::shutter::box_param* unsafe_arena_release_verify_box1();

  // optional .shutter.box_param verify_box2 = 4;
  bool has_verify_box2() const;
  private:
  bool _internal_has_verify_box2() const;
  public:
  void clear_verify_box2();
  const ::shutter::box_param& verify_box2() const;
  ::shutter::box_param* release_verify_box2();
  ::shutter::box_param* mutable_verify_box2();
  void set_allocated_verify_box2(::shutter::box_param* verify_box2);
  private:
  const ::shutter::box_param& _internal_verify_box2() const;
  ::shutter::box_param* _internal_mutable_verify_box2();
  public:
  void unsafe_arena_set_allocated_verify_box2(
      ::shutter::box_param* verify_box2);
  ::shutter::box_param* unsafe_arena_release_verify_box2();

  // @@protoc_insertion_point(class_scope:shutter.shutter_param)
 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::RepeatedPtrField< ::shutter::lidar_parameter > lidars_;
  ::shutter::box_param* box_;
  ::shutter::box_param* verify_box1_;
  ::shutter::box_param* verify_box2_;
  friend struct ::TableStruct_setting_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline setting_parameter& operator=(const setting_parameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline setting_parameter& operator=(setting_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 setting_parameter& default_instance();

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

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

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

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

  setting_parameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<setting_parameter>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const setting_parameter& from);
  void MergeFrom(const setting_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(setting_parameter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "shutter.setting_parameter";
  }
  protected:
  explicit setting_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_setting_2eproto);
    return ::descriptor_table_setting_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kEntranceParameterFieldNumber = 1,
    kExportParameterFieldNumber = 2,
    kPlcSettingFieldNumber = 3,
  };
  // optional .shutter.shutter_param entrance_parameter = 1;
  bool has_entrance_parameter() const;
  private:
  bool _internal_has_entrance_parameter() const;
  public:
  void clear_entrance_parameter();
  const ::shutter::shutter_param& entrance_parameter() const;
  ::shutter::shutter_param* release_entrance_parameter();
  ::shutter::shutter_param* mutable_entrance_parameter();
  void set_allocated_entrance_parameter(::shutter::shutter_param* entrance_parameter);
  private:
  const ::shutter::shutter_param& _internal_entrance_parameter() const;
  ::shutter::shutter_param* _internal_mutable_entrance_parameter();
  public:
  void unsafe_arena_set_allocated_entrance_parameter(
      ::shutter::shutter_param* entrance_parameter);
  ::shutter::shutter_param* unsafe_arena_release_entrance_parameter();

  // optional .shutter.shutter_param export_parameter = 2;
  bool has_export_parameter() const;
  private:
  bool _internal_has_export_parameter() const;
  public:
  void clear_export_parameter();
  const ::shutter::shutter_param& export_parameter() const;
  ::shutter::shutter_param* release_export_parameter();
  ::shutter::shutter_param* mutable_export_parameter();
  void set_allocated_export_parameter(::shutter::shutter_param* export_parameter);
  private:
  const ::shutter::shutter_param& _internal_export_parameter() const;
  ::shutter::shutter_param* _internal_mutable_export_parameter();
  public:
  void unsafe_arena_set_allocated_export_parameter(
      ::shutter::shutter_param* export_parameter);
  ::shutter::shutter_param* unsafe_arena_release_export_parameter();

  // required .shutter.plc_param plc_setting = 3;
  bool has_plc_setting() const;
  private:
  bool _internal_has_plc_setting() const;
  public:
  void clear_plc_setting();
  const ::shutter::plc_param& plc_setting() const;
  ::shutter::plc_param* release_plc_setting();
  ::shutter::plc_param* mutable_plc_setting();
  void set_allocated_plc_setting(::shutter::plc_param* plc_setting);
  private:
  const ::shutter::plc_param& _internal_plc_setting() const;
  ::shutter::plc_param* _internal_mutable_plc_setting();
  public:
  void unsafe_arena_set_allocated_plc_setting(
      ::shutter::plc_param* plc_setting);
  ::shutter::plc_param* unsafe_arena_release_plc_setting();

  // @@protoc_insertion_point(class_scope:shutter.setting_parameter)
 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_;
  ::shutter::shutter_param* entrance_parameter_;
  ::shutter::shutter_param* export_parameter_;
  ::shutter::plc_param* plc_setting_;
  friend struct ::TableStruct_setting_2eproto;
};
// ===================================================================


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

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

// optional string sncode = 1;
inline bool lidar_parameter::_internal_has_sncode() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool lidar_parameter::has_sncode() const {
  return _internal_has_sncode();
}
inline void lidar_parameter::clear_sncode() {
  sncode_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& lidar_parameter::sncode() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.sncode)
  return _internal_sncode();
}
inline void lidar_parameter::set_sncode(const std::string& value) {
  _internal_set_sncode(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.sncode)
}
inline std::string* lidar_parameter::mutable_sncode() {
  // @@protoc_insertion_point(field_mutable:shutter.lidar_parameter.sncode)
  return _internal_mutable_sncode();
}
inline const std::string& lidar_parameter::_internal_sncode() const {
  return sncode_.Get();
}
inline void lidar_parameter::_internal_set_sncode(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  sncode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void lidar_parameter::set_sncode(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  sncode_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:shutter.lidar_parameter.sncode)
}
inline void lidar_parameter::set_sncode(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  sncode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:shutter.lidar_parameter.sncode)
}
inline void lidar_parameter::set_sncode(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  sncode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:shutter.lidar_parameter.sncode)
}
inline std::string* lidar_parameter::_internal_mutable_sncode() {
  _has_bits_[0] |= 0x00000001u;
  return sncode_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* lidar_parameter::release_sncode() {
  // @@protoc_insertion_point(field_release:shutter.lidar_parameter.sncode)
  if (!_internal_has_sncode()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return sncode_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void lidar_parameter::set_allocated_sncode(std::string* sncode) {
  if (sncode != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  sncode_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sncode,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:shutter.lidar_parameter.sncode)
}

// optional double r = 2 [default = 0];
inline bool lidar_parameter::_internal_has_r() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool lidar_parameter::has_r() const {
  return _internal_has_r();
}
inline void lidar_parameter::clear_r() {
  r_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double lidar_parameter::_internal_r() const {
  return r_;
}
inline double lidar_parameter::r() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.r)
  return _internal_r();
}
inline void lidar_parameter::_internal_set_r(double value) {
  _has_bits_[0] |= 0x00000002u;
  r_ = value;
}
inline void lidar_parameter::set_r(double value) {
  _internal_set_r(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.r)
}

// optional double p = 3 [default = 0];
inline bool lidar_parameter::_internal_has_p() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool lidar_parameter::has_p() const {
  return _internal_has_p();
}
inline void lidar_parameter::clear_p() {
  p_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double lidar_parameter::_internal_p() const {
  return p_;
}
inline double lidar_parameter::p() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.p)
  return _internal_p();
}
inline void lidar_parameter::_internal_set_p(double value) {
  _has_bits_[0] |= 0x00000004u;
  p_ = value;
}
inline void lidar_parameter::set_p(double value) {
  _internal_set_p(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.p)
}

// optional double y = 4 [default = 0];
inline bool lidar_parameter::_internal_has_y() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool lidar_parameter::has_y() const {
  return _internal_has_y();
}
inline void lidar_parameter::clear_y() {
  y_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double lidar_parameter::_internal_y() const {
  return y_;
}
inline double lidar_parameter::y() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.y)
  return _internal_y();
}
inline void lidar_parameter::_internal_set_y(double value) {
  _has_bits_[0] |= 0x00000008u;
  y_ = value;
}
inline void lidar_parameter::set_y(double value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.y)
}

// optional double tx = 5 [default = 1];
inline bool lidar_parameter::_internal_has_tx() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool lidar_parameter::has_tx() const {
  return _internal_has_tx();
}
inline void lidar_parameter::clear_tx() {
  tx_ = 1;
  _has_bits_[0] &= ~0x00000010u;
}
inline double lidar_parameter::_internal_tx() const {
  return tx_;
}
inline double lidar_parameter::tx() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.tx)
  return _internal_tx();
}
inline void lidar_parameter::_internal_set_tx(double value) {
  _has_bits_[0] |= 0x00000010u;
  tx_ = value;
}
inline void lidar_parameter::set_tx(double value) {
  _internal_set_tx(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.tx)
}

// optional double ty = 6 [default = 1];
inline bool lidar_parameter::_internal_has_ty() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool lidar_parameter::has_ty() const {
  return _internal_has_ty();
}
inline void lidar_parameter::clear_ty() {
  ty_ = 1;
  _has_bits_[0] &= ~0x00000020u;
}
inline double lidar_parameter::_internal_ty() const {
  return ty_;
}
inline double lidar_parameter::ty() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.ty)
  return _internal_ty();
}
inline void lidar_parameter::_internal_set_ty(double value) {
  _has_bits_[0] |= 0x00000020u;
  ty_ = value;
}
inline void lidar_parameter::set_ty(double value) {
  _internal_set_ty(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.ty)
}

// optional double tz = 7 [default = 1];
inline bool lidar_parameter::_internal_has_tz() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool lidar_parameter::has_tz() const {
  return _internal_has_tz();
}
inline void lidar_parameter::clear_tz() {
  tz_ = 1;
  _has_bits_[0] &= ~0x00000040u;
}
inline double lidar_parameter::_internal_tz() const {
  return tz_;
}
inline double lidar_parameter::tz() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.tz)
  return _internal_tz();
}
inline void lidar_parameter::_internal_set_tz(double value) {
  _has_bits_[0] |= 0x00000040u;
  tz_ = value;
}
inline void lidar_parameter::set_tz(double value) {
  _internal_set_tz(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.tz)
}

// optional double fps = 8 [default = 10];
inline bool lidar_parameter::_internal_has_fps() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool lidar_parameter::has_fps() const {
  return _internal_has_fps();
}
inline void lidar_parameter::clear_fps() {
  fps_ = 10;
  _has_bits_[0] &= ~0x00000080u;
}
inline double lidar_parameter::_internal_fps() const {
  return fps_;
}
inline double lidar_parameter::fps() const {
  // @@protoc_insertion_point(field_get:shutter.lidar_parameter.fps)
  return _internal_fps();
}
inline void lidar_parameter::_internal_set_fps(double value) {
  _has_bits_[0] |= 0x00000080u;
  fps_ = value;
}
inline void lidar_parameter::set_fps(double value) {
  _internal_set_fps(value);
  // @@protoc_insertion_point(field_set:shutter.lidar_parameter.fps)
}

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

// box_param

// optional double minx = 1;
inline bool box_param::_internal_has_minx() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool box_param::has_minx() const {
  return _internal_has_minx();
}
inline void box_param::clear_minx() {
  minx_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double box_param::_internal_minx() const {
  return minx_;
}
inline double box_param::minx() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.minx)
  return _internal_minx();
}
inline void box_param::_internal_set_minx(double value) {
  _has_bits_[0] |= 0x00000001u;
  minx_ = value;
}
inline void box_param::set_minx(double value) {
  _internal_set_minx(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.minx)
}

// optional double maxx = 2;
inline bool box_param::_internal_has_maxx() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool box_param::has_maxx() const {
  return _internal_has_maxx();
}
inline void box_param::clear_maxx() {
  maxx_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double box_param::_internal_maxx() const {
  return maxx_;
}
inline double box_param::maxx() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.maxx)
  return _internal_maxx();
}
inline void box_param::_internal_set_maxx(double value) {
  _has_bits_[0] |= 0x00000002u;
  maxx_ = value;
}
inline void box_param::set_maxx(double value) {
  _internal_set_maxx(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.maxx)
}

// optional double miny = 3;
inline bool box_param::_internal_has_miny() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool box_param::has_miny() const {
  return _internal_has_miny();
}
inline void box_param::clear_miny() {
  miny_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double box_param::_internal_miny() const {
  return miny_;
}
inline double box_param::miny() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.miny)
  return _internal_miny();
}
inline void box_param::_internal_set_miny(double value) {
  _has_bits_[0] |= 0x00000004u;
  miny_ = value;
}
inline void box_param::set_miny(double value) {
  _internal_set_miny(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.miny)
}

// optional double maxy = 4;
inline bool box_param::_internal_has_maxy() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool box_param::has_maxy() const {
  return _internal_has_maxy();
}
inline void box_param::clear_maxy() {
  maxy_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double box_param::_internal_maxy() const {
  return maxy_;
}
inline double box_param::maxy() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.maxy)
  return _internal_maxy();
}
inline void box_param::_internal_set_maxy(double value) {
  _has_bits_[0] |= 0x00000008u;
  maxy_ = value;
}
inline void box_param::set_maxy(double value) {
  _internal_set_maxy(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.maxy)
}

// optional double minz = 5;
inline bool box_param::_internal_has_minz() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool box_param::has_minz() const {
  return _internal_has_minz();
}
inline void box_param::clear_minz() {
  minz_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double box_param::_internal_minz() const {
  return minz_;
}
inline double box_param::minz() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.minz)
  return _internal_minz();
}
inline void box_param::_internal_set_minz(double value) {
  _has_bits_[0] |= 0x00000010u;
  minz_ = value;
}
inline void box_param::set_minz(double value) {
  _internal_set_minz(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.minz)
}

// optional double maxz = 6;
inline bool box_param::_internal_has_maxz() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool box_param::has_maxz() const {
  return _internal_has_maxz();
}
inline void box_param::clear_maxz() {
  maxz_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline double box_param::_internal_maxz() const {
  return maxz_;
}
inline double box_param::maxz() const {
  // @@protoc_insertion_point(field_get:shutter.box_param.maxz)
  return _internal_maxz();
}
inline void box_param::_internal_set_maxz(double value) {
  _has_bits_[0] |= 0x00000020u;
  maxz_ = value;
}
inline void box_param::set_maxz(double value) {
  _internal_set_maxz(value);
  // @@protoc_insertion_point(field_set:shutter.box_param.maxz)
}

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

// plc_param

// required string ip = 1;
inline bool plc_param::_internal_has_ip() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool plc_param::has_ip() const {
  return _internal_has_ip();
}
inline void plc_param::clear_ip() {
  ip_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& plc_param::ip() const {
  // @@protoc_insertion_point(field_get:shutter.plc_param.ip)
  return _internal_ip();
}
inline void plc_param::set_ip(const std::string& value) {
  _internal_set_ip(value);
  // @@protoc_insertion_point(field_set:shutter.plc_param.ip)
}
inline std::string* plc_param::mutable_ip() {
  // @@protoc_insertion_point(field_mutable:shutter.plc_param.ip)
  return _internal_mutable_ip();
}
inline const std::string& plc_param::_internal_ip() const {
  return ip_.Get();
}
inline void plc_param::_internal_set_ip(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void plc_param::set_ip(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  ip_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:shutter.plc_param.ip)
}
inline void plc_param::set_ip(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:shutter.plc_param.ip)
}
inline void plc_param::set_ip(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:shutter.plc_param.ip)
}
inline std::string* plc_param::_internal_mutable_ip() {
  _has_bits_[0] |= 0x00000001u;
  return ip_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* plc_param::release_ip() {
  // @@protoc_insertion_point(field_release:shutter.plc_param.ip)
  if (!_internal_has_ip()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return ip_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void plc_param::set_allocated_ip(std::string* ip) {
  if (ip != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:shutter.plc_param.ip)
}

// required int32 dbnumber = 2;
inline bool plc_param::_internal_has_dbnumber() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool plc_param::has_dbnumber() const {
  return _internal_has_dbnumber();
}
inline void plc_param::clear_dbnumber() {
  dbnumber_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::_internal_dbnumber() const {
  return dbnumber_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::dbnumber() const {
  // @@protoc_insertion_point(field_get:shutter.plc_param.dbnumber)
  return _internal_dbnumber();
}
inline void plc_param::_internal_set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  dbnumber_ = value;
}
inline void plc_param::set_dbnumber(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_dbnumber(value);
  // @@protoc_insertion_point(field_set:shutter.plc_param.dbnumber)
}

// optional int32 start_id = 3 [default = 0];
inline bool plc_param::_internal_has_start_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool plc_param::has_start_id() const {
  return _internal_has_start_id();
}
inline void plc_param::clear_start_id() {
  start_id_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::_internal_start_id() const {
  return start_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plc_param::start_id() const {
  // @@protoc_insertion_point(field_get:shutter.plc_param.start_id)
  return _internal_start_id();
}
inline void plc_param::_internal_set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  start_id_ = value;
}
inline void plc_param::set_start_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_start_id(value);
  // @@protoc_insertion_point(field_set:shutter.plc_param.start_id)
}

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

// shutter_param

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

// optional .shutter.box_param box = 2;
inline bool shutter_param::_internal_has_box() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || box_ != nullptr);
  return value;
}
inline bool shutter_param::has_box() const {
  return _internal_has_box();
}
inline void shutter_param::clear_box() {
  if (box_ != nullptr) box_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::shutter::box_param& shutter_param::_internal_box() const {
  const ::shutter::box_param* p = box_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::box_param*>(
      &::shutter::_box_param_default_instance_);
}
inline const ::shutter::box_param& shutter_param::box() const {
  // @@protoc_insertion_point(field_get:shutter.shutter_param.box)
  return _internal_box();
}
inline void shutter_param::unsafe_arena_set_allocated_box(
    ::shutter::box_param* box) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(box_);
  }
  box_ = box;
  if (box) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.shutter_param.box)
}
inline ::shutter::box_param* shutter_param::release_box() {
  _has_bits_[0] &= ~0x00000001u;
  ::shutter::box_param* temp = box_;
  box_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::box_param* shutter_param::unsafe_arena_release_box() {
  // @@protoc_insertion_point(field_release:shutter.shutter_param.box)
  _has_bits_[0] &= ~0x00000001u;
  ::shutter::box_param* temp = box_;
  box_ = nullptr;
  return temp;
}
inline ::shutter::box_param* shutter_param::_internal_mutable_box() {
  _has_bits_[0] |= 0x00000001u;
  if (box_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::box_param>(GetArena());
    box_ = p;
  }
  return box_;
}
inline ::shutter::box_param* shutter_param::mutable_box() {
  // @@protoc_insertion_point(field_mutable:shutter.shutter_param.box)
  return _internal_mutable_box();
}
inline void shutter_param::set_allocated_box(::shutter::box_param* box) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete box_;
  }
  if (box) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(box);
    if (message_arena != submessage_arena) {
      box = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, box, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  box_ = box;
  // @@protoc_insertion_point(field_set_allocated:shutter.shutter_param.box)
}

// optional .shutter.box_param verify_box1 = 3;
inline bool shutter_param::_internal_has_verify_box1() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || verify_box1_ != nullptr);
  return value;
}
inline bool shutter_param::has_verify_box1() const {
  return _internal_has_verify_box1();
}
inline void shutter_param::clear_verify_box1() {
  if (verify_box1_ != nullptr) verify_box1_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::shutter::box_param& shutter_param::_internal_verify_box1() const {
  const ::shutter::box_param* p = verify_box1_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::box_param*>(
      &::shutter::_box_param_default_instance_);
}
inline const ::shutter::box_param& shutter_param::verify_box1() const {
  // @@protoc_insertion_point(field_get:shutter.shutter_param.verify_box1)
  return _internal_verify_box1();
}
inline void shutter_param::unsafe_arena_set_allocated_verify_box1(
    ::shutter::box_param* verify_box1) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(verify_box1_);
  }
  verify_box1_ = verify_box1;
  if (verify_box1) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.shutter_param.verify_box1)
}
inline ::shutter::box_param* shutter_param::release_verify_box1() {
  _has_bits_[0] &= ~0x00000002u;
  ::shutter::box_param* temp = verify_box1_;
  verify_box1_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::box_param* shutter_param::unsafe_arena_release_verify_box1() {
  // @@protoc_insertion_point(field_release:shutter.shutter_param.verify_box1)
  _has_bits_[0] &= ~0x00000002u;
  ::shutter::box_param* temp = verify_box1_;
  verify_box1_ = nullptr;
  return temp;
}
inline ::shutter::box_param* shutter_param::_internal_mutable_verify_box1() {
  _has_bits_[0] |= 0x00000002u;
  if (verify_box1_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::box_param>(GetArena());
    verify_box1_ = p;
  }
  return verify_box1_;
}
inline ::shutter::box_param* shutter_param::mutable_verify_box1() {
  // @@protoc_insertion_point(field_mutable:shutter.shutter_param.verify_box1)
  return _internal_mutable_verify_box1();
}
inline void shutter_param::set_allocated_verify_box1(::shutter::box_param* verify_box1) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete verify_box1_;
  }
  if (verify_box1) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(verify_box1);
    if (message_arena != submessage_arena) {
      verify_box1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, verify_box1, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  verify_box1_ = verify_box1;
  // @@protoc_insertion_point(field_set_allocated:shutter.shutter_param.verify_box1)
}

// optional .shutter.box_param verify_box2 = 4;
inline bool shutter_param::_internal_has_verify_box2() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || verify_box2_ != nullptr);
  return value;
}
inline bool shutter_param::has_verify_box2() const {
  return _internal_has_verify_box2();
}
inline void shutter_param::clear_verify_box2() {
  if (verify_box2_ != nullptr) verify_box2_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::shutter::box_param& shutter_param::_internal_verify_box2() const {
  const ::shutter::box_param* p = verify_box2_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::box_param*>(
      &::shutter::_box_param_default_instance_);
}
inline const ::shutter::box_param& shutter_param::verify_box2() const {
  // @@protoc_insertion_point(field_get:shutter.shutter_param.verify_box2)
  return _internal_verify_box2();
}
inline void shutter_param::unsafe_arena_set_allocated_verify_box2(
    ::shutter::box_param* verify_box2) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(verify_box2_);
  }
  verify_box2_ = verify_box2;
  if (verify_box2) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.shutter_param.verify_box2)
}
inline ::shutter::box_param* shutter_param::release_verify_box2() {
  _has_bits_[0] &= ~0x00000004u;
  ::shutter::box_param* temp = verify_box2_;
  verify_box2_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::box_param* shutter_param::unsafe_arena_release_verify_box2() {
  // @@protoc_insertion_point(field_release:shutter.shutter_param.verify_box2)
  _has_bits_[0] &= ~0x00000004u;
  ::shutter::box_param* temp = verify_box2_;
  verify_box2_ = nullptr;
  return temp;
}
inline ::shutter::box_param* shutter_param::_internal_mutable_verify_box2() {
  _has_bits_[0] |= 0x00000004u;
  if (verify_box2_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::box_param>(GetArena());
    verify_box2_ = p;
  }
  return verify_box2_;
}
inline ::shutter::box_param* shutter_param::mutable_verify_box2() {
  // @@protoc_insertion_point(field_mutable:shutter.shutter_param.verify_box2)
  return _internal_mutable_verify_box2();
}
inline void shutter_param::set_allocated_verify_box2(::shutter::box_param* verify_box2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete verify_box2_;
  }
  if (verify_box2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(verify_box2);
    if (message_arena != submessage_arena) {
      verify_box2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, verify_box2, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  verify_box2_ = verify_box2;
  // @@protoc_insertion_point(field_set_allocated:shutter.shutter_param.verify_box2)
}

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

// setting_parameter

// optional .shutter.shutter_param entrance_parameter = 1;
inline bool setting_parameter::_internal_has_entrance_parameter() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || entrance_parameter_ != nullptr);
  return value;
}
inline bool setting_parameter::has_entrance_parameter() const {
  return _internal_has_entrance_parameter();
}
inline void setting_parameter::clear_entrance_parameter() {
  if (entrance_parameter_ != nullptr) entrance_parameter_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::shutter::shutter_param& setting_parameter::_internal_entrance_parameter() const {
  const ::shutter::shutter_param* p = entrance_parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::shutter_param*>(
      &::shutter::_shutter_param_default_instance_);
}
inline const ::shutter::shutter_param& setting_parameter::entrance_parameter() const {
  // @@protoc_insertion_point(field_get:shutter.setting_parameter.entrance_parameter)
  return _internal_entrance_parameter();
}
inline void setting_parameter::unsafe_arena_set_allocated_entrance_parameter(
    ::shutter::shutter_param* entrance_parameter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entrance_parameter_);
  }
  entrance_parameter_ = entrance_parameter;
  if (entrance_parameter) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.entrance_parameter)
}
inline ::shutter::shutter_param* setting_parameter::release_entrance_parameter() {
  _has_bits_[0] &= ~0x00000001u;
  ::shutter::shutter_param* temp = entrance_parameter_;
  entrance_parameter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::shutter_param* setting_parameter::unsafe_arena_release_entrance_parameter() {
  // @@protoc_insertion_point(field_release:shutter.setting_parameter.entrance_parameter)
  _has_bits_[0] &= ~0x00000001u;
  ::shutter::shutter_param* temp = entrance_parameter_;
  entrance_parameter_ = nullptr;
  return temp;
}
inline ::shutter::shutter_param* setting_parameter::_internal_mutable_entrance_parameter() {
  _has_bits_[0] |= 0x00000001u;
  if (entrance_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::shutter_param>(GetArena());
    entrance_parameter_ = p;
  }
  return entrance_parameter_;
}
inline ::shutter::shutter_param* setting_parameter::mutable_entrance_parameter() {
  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.entrance_parameter)
  return _internal_mutable_entrance_parameter();
}
inline void setting_parameter::set_allocated_entrance_parameter(::shutter::shutter_param* entrance_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete entrance_parameter_;
  }
  if (entrance_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(entrance_parameter);
    if (message_arena != submessage_arena) {
      entrance_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, entrance_parameter, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  entrance_parameter_ = entrance_parameter;
  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.entrance_parameter)
}

// optional .shutter.shutter_param export_parameter = 2;
inline bool setting_parameter::_internal_has_export_parameter() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || export_parameter_ != nullptr);
  return value;
}
inline bool setting_parameter::has_export_parameter() const {
  return _internal_has_export_parameter();
}
inline void setting_parameter::clear_export_parameter() {
  if (export_parameter_ != nullptr) export_parameter_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::shutter::shutter_param& setting_parameter::_internal_export_parameter() const {
  const ::shutter::shutter_param* p = export_parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::shutter_param*>(
      &::shutter::_shutter_param_default_instance_);
}
inline const ::shutter::shutter_param& setting_parameter::export_parameter() const {
  // @@protoc_insertion_point(field_get:shutter.setting_parameter.export_parameter)
  return _internal_export_parameter();
}
inline void setting_parameter::unsafe_arena_set_allocated_export_parameter(
    ::shutter::shutter_param* export_parameter) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(export_parameter_);
  }
  export_parameter_ = export_parameter;
  if (export_parameter) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.export_parameter)
}
inline ::shutter::shutter_param* setting_parameter::release_export_parameter() {
  _has_bits_[0] &= ~0x00000002u;
  ::shutter::shutter_param* temp = export_parameter_;
  export_parameter_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::shutter_param* setting_parameter::unsafe_arena_release_export_parameter() {
  // @@protoc_insertion_point(field_release:shutter.setting_parameter.export_parameter)
  _has_bits_[0] &= ~0x00000002u;
  ::shutter::shutter_param* temp = export_parameter_;
  export_parameter_ = nullptr;
  return temp;
}
inline ::shutter::shutter_param* setting_parameter::_internal_mutable_export_parameter() {
  _has_bits_[0] |= 0x00000002u;
  if (export_parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::shutter_param>(GetArena());
    export_parameter_ = p;
  }
  return export_parameter_;
}
inline ::shutter::shutter_param* setting_parameter::mutable_export_parameter() {
  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.export_parameter)
  return _internal_mutable_export_parameter();
}
inline void setting_parameter::set_allocated_export_parameter(::shutter::shutter_param* export_parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete export_parameter_;
  }
  if (export_parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(export_parameter);
    if (message_arena != submessage_arena) {
      export_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, export_parameter, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  export_parameter_ = export_parameter;
  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.export_parameter)
}

// required .shutter.plc_param plc_setting = 3;
inline bool setting_parameter::_internal_has_plc_setting() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || plc_setting_ != nullptr);
  return value;
}
inline bool setting_parameter::has_plc_setting() const {
  return _internal_has_plc_setting();
}
inline void setting_parameter::clear_plc_setting() {
  if (plc_setting_ != nullptr) plc_setting_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::shutter::plc_param& setting_parameter::_internal_plc_setting() const {
  const ::shutter::plc_param* p = plc_setting_;
  return p != nullptr ? *p : *reinterpret_cast<const ::shutter::plc_param*>(
      &::shutter::_plc_param_default_instance_);
}
inline const ::shutter::plc_param& setting_parameter::plc_setting() const {
  // @@protoc_insertion_point(field_get:shutter.setting_parameter.plc_setting)
  return _internal_plc_setting();
}
inline void setting_parameter::unsafe_arena_set_allocated_plc_setting(
    ::shutter::plc_param* plc_setting) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(plc_setting_);
  }
  plc_setting_ = plc_setting;
  if (plc_setting) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:shutter.setting_parameter.plc_setting)
}
inline ::shutter::plc_param* setting_parameter::release_plc_setting() {
  _has_bits_[0] &= ~0x00000004u;
  ::shutter::plc_param* temp = plc_setting_;
  plc_setting_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::shutter::plc_param* setting_parameter::unsafe_arena_release_plc_setting() {
  // @@protoc_insertion_point(field_release:shutter.setting_parameter.plc_setting)
  _has_bits_[0] &= ~0x00000004u;
  ::shutter::plc_param* temp = plc_setting_;
  plc_setting_ = nullptr;
  return temp;
}
inline ::shutter::plc_param* setting_parameter::_internal_mutable_plc_setting() {
  _has_bits_[0] |= 0x00000004u;
  if (plc_setting_ == nullptr) {
    auto* p = CreateMaybeMessage<::shutter::plc_param>(GetArena());
    plc_setting_ = p;
  }
  return plc_setting_;
}
inline ::shutter::plc_param* setting_parameter::mutable_plc_setting() {
  // @@protoc_insertion_point(field_mutable:shutter.setting_parameter.plc_setting)
  return _internal_mutable_plc_setting();
}
inline void setting_parameter::set_allocated_plc_setting(::shutter::plc_param* plc_setting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete plc_setting_;
  }
  if (plc_setting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(plc_setting);
    if (message_arena != submessage_arena) {
      plc_setting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, plc_setting, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  plc_setting_ = plc_setting;
  // @@protoc_insertion_point(field_set_allocated:shutter.setting_parameter.plc_setting)
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace shutter

// @@protoc_insertion_point(global_scope)

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