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

#ifndef GOOGLE_PROTOBUF_INCLUDED_battery_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_battery_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_battery_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_battery_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_battery_2eproto;
namespace BatteryConfig {
class Attributes;
struct AttributesDefaultTypeInternal;
extern AttributesDefaultTypeInternal _Attributes_default_instance_;
class Attributes_DIDO;
struct Attributes_DIDODefaultTypeInternal;
extern Attributes_DIDODefaultTypeInternal _Attributes_DIDO_default_instance_;
class Attributes_SOX;
struct Attributes_SOXDefaultTypeInternal;
extern Attributes_SOXDefaultTypeInternal _Attributes_SOX_default_instance_;
class Attributes_alert_delay;
struct Attributes_alert_delayDefaultTypeInternal;
extern Attributes_alert_delayDefaultTypeInternal _Attributes_alert_delay_default_instance_;
class Attributes_alert_dropcurr_rate;
struct Attributes_alert_dropcurr_rateDefaultTypeInternal;
extern Attributes_alert_dropcurr_rateDefaultTypeInternal _Attributes_alert_dropcurr_rate_default_instance_;
class Attributes_alert_release_delay;
struct Attributes_alert_release_delayDefaultTypeInternal;
extern Attributes_alert_release_delayDefaultTypeInternal _Attributes_alert_release_delay_default_instance_;
class Attributes_alert_release_value;
struct Attributes_alert_release_valueDefaultTypeInternal;
extern Attributes_alert_release_valueDefaultTypeInternal _Attributes_alert_release_value_default_instance_;
class Attributes_alert_solve_measure;
struct Attributes_alert_solve_measureDefaultTypeInternal;
extern Attributes_alert_solve_measureDefaultTypeInternal _Attributes_alert_solve_measure_default_instance_;
class Attributes_alert_value;
struct Attributes_alert_valueDefaultTypeInternal;
extern Attributes_alert_valueDefaultTypeInternal _Attributes_alert_value_default_instance_;
class Attributes_balance;
struct Attributes_balanceDefaultTypeInternal;
extern Attributes_balanceDefaultTypeInternal _Attributes_balance_default_instance_;
class Attributes_other;
struct Attributes_otherDefaultTypeInternal;
extern Attributes_otherDefaultTypeInternal _Attributes_other_default_instance_;
class Item;
struct ItemDefaultTypeInternal;
extern ItemDefaultTypeInternal _Item_default_instance_;
}  // namespace BatteryConfig
PROTOBUF_NAMESPACE_OPEN
template<> ::BatteryConfig::Attributes* Arena::CreateMaybeMessage<::BatteryConfig::Attributes>(Arena*);
template<> ::BatteryConfig::Attributes_DIDO* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_DIDO>(Arena*);
template<> ::BatteryConfig::Attributes_SOX* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_SOX>(Arena*);
template<> ::BatteryConfig::Attributes_alert_delay* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_delay>(Arena*);
template<> ::BatteryConfig::Attributes_alert_dropcurr_rate* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_dropcurr_rate>(Arena*);
template<> ::BatteryConfig::Attributes_alert_release_delay* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_release_delay>(Arena*);
template<> ::BatteryConfig::Attributes_alert_release_value* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_release_value>(Arena*);
template<> ::BatteryConfig::Attributes_alert_solve_measure* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_solve_measure>(Arena*);
template<> ::BatteryConfig::Attributes_alert_value* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_alert_value>(Arena*);
template<> ::BatteryConfig::Attributes_balance* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_balance>(Arena*);
template<> ::BatteryConfig::Attributes_other* Arena::CreateMaybeMessage<::BatteryConfig::Attributes_other>(Arena*);
template<> ::BatteryConfig::Item* Arena::CreateMaybeMessage<::BatteryConfig::Item>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace BatteryConfig {

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

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

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

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

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

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

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

  Item* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Item>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Item& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Item& from) {
    Item::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kItemAttrFieldNumber = 1,
    kItemAttrBalanceFieldNumber = 2,
    kItemAttrDIDOFieldNumber = 3,
    kItemAttrSOXFieldNumber = 4,
    kItemAttrOtherFieldNumber = 5,
    kItemAttrAlertValueFieldNumber = 6,
    kItemAttrAlertDelayFieldNumber = 7,
    kItemAttrAlertReleaseValueFieldNumber = 8,
    kItemAttrAlertReleaseDelayFieldNumber = 9,
    kItemAttrAlertDropcurrRateFieldNumber = 10,
    kItemAttrAlertSolveMeasureFieldNumber = 11,
  };
  // repeated .BatteryConfig.Attributes ItemAttr = 1;
  int itemattr_size() const;
  private:
  int _internal_itemattr_size() const;
  public:
  void clear_itemattr();
  ::BatteryConfig::Attributes* mutable_itemattr(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes >*
      mutable_itemattr();
  private:
  const ::BatteryConfig::Attributes& _internal_itemattr(int index) const;
  ::BatteryConfig::Attributes* _internal_add_itemattr();
  public:
  const ::BatteryConfig::Attributes& itemattr(int index) const;
  ::BatteryConfig::Attributes* add_itemattr();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes >&
      itemattr() const;

  // repeated .BatteryConfig.Attributes_balance ItemAttr_balance = 2;
  int itemattr_balance_size() const;
  private:
  int _internal_itemattr_balance_size() const;
  public:
  void clear_itemattr_balance();
  ::BatteryConfig::Attributes_balance* mutable_itemattr_balance(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_balance >*
      mutable_itemattr_balance();
  private:
  const ::BatteryConfig::Attributes_balance& _internal_itemattr_balance(int index) const;
  ::BatteryConfig::Attributes_balance* _internal_add_itemattr_balance();
  public:
  const ::BatteryConfig::Attributes_balance& itemattr_balance(int index) const;
  ::BatteryConfig::Attributes_balance* add_itemattr_balance();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_balance >&
      itemattr_balance() const;

  // repeated .BatteryConfig.Attributes_DIDO ItemAttr_DIDO = 3;
  int itemattr_dido_size() const;
  private:
  int _internal_itemattr_dido_size() const;
  public:
  void clear_itemattr_dido();
  ::BatteryConfig::Attributes_DIDO* mutable_itemattr_dido(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_DIDO >*
      mutable_itemattr_dido();
  private:
  const ::BatteryConfig::Attributes_DIDO& _internal_itemattr_dido(int index) const;
  ::BatteryConfig::Attributes_DIDO* _internal_add_itemattr_dido();
  public:
  const ::BatteryConfig::Attributes_DIDO& itemattr_dido(int index) const;
  ::BatteryConfig::Attributes_DIDO* add_itemattr_dido();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_DIDO >&
      itemattr_dido() const;

  // repeated .BatteryConfig.Attributes_SOX ItemAttr_SOX = 4;
  int itemattr_sox_size() const;
  private:
  int _internal_itemattr_sox_size() const;
  public:
  void clear_itemattr_sox();
  ::BatteryConfig::Attributes_SOX* mutable_itemattr_sox(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_SOX >*
      mutable_itemattr_sox();
  private:
  const ::BatteryConfig::Attributes_SOX& _internal_itemattr_sox(int index) const;
  ::BatteryConfig::Attributes_SOX* _internal_add_itemattr_sox();
  public:
  const ::BatteryConfig::Attributes_SOX& itemattr_sox(int index) const;
  ::BatteryConfig::Attributes_SOX* add_itemattr_sox();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_SOX >&
      itemattr_sox() const;

  // repeated .BatteryConfig.Attributes_other ItemAttr_other = 5;
  int itemattr_other_size() const;
  private:
  int _internal_itemattr_other_size() const;
  public:
  void clear_itemattr_other();
  ::BatteryConfig::Attributes_other* mutable_itemattr_other(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_other >*
      mutable_itemattr_other();
  private:
  const ::BatteryConfig::Attributes_other& _internal_itemattr_other(int index) const;
  ::BatteryConfig::Attributes_other* _internal_add_itemattr_other();
  public:
  const ::BatteryConfig::Attributes_other& itemattr_other(int index) const;
  ::BatteryConfig::Attributes_other* add_itemattr_other();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_other >&
      itemattr_other() const;

  // repeated .BatteryConfig.Attributes_alert_value ItemAttr_alert_value = 6;
  int itemattr_alert_value_size() const;
  private:
  int _internal_itemattr_alert_value_size() const;
  public:
  void clear_itemattr_alert_value();
  ::BatteryConfig::Attributes_alert_value* mutable_itemattr_alert_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_value >*
      mutable_itemattr_alert_value();
  private:
  const ::BatteryConfig::Attributes_alert_value& _internal_itemattr_alert_value(int index) const;
  ::BatteryConfig::Attributes_alert_value* _internal_add_itemattr_alert_value();
  public:
  const ::BatteryConfig::Attributes_alert_value& itemattr_alert_value(int index) const;
  ::BatteryConfig::Attributes_alert_value* add_itemattr_alert_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_value >&
      itemattr_alert_value() const;

  // repeated .BatteryConfig.Attributes_alert_delay ItemAttr_alert_delay = 7;
  int itemattr_alert_delay_size() const;
  private:
  int _internal_itemattr_alert_delay_size() const;
  public:
  void clear_itemattr_alert_delay();
  ::BatteryConfig::Attributes_alert_delay* mutable_itemattr_alert_delay(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_delay >*
      mutable_itemattr_alert_delay();
  private:
  const ::BatteryConfig::Attributes_alert_delay& _internal_itemattr_alert_delay(int index) const;
  ::BatteryConfig::Attributes_alert_delay* _internal_add_itemattr_alert_delay();
  public:
  const ::BatteryConfig::Attributes_alert_delay& itemattr_alert_delay(int index) const;
  ::BatteryConfig::Attributes_alert_delay* add_itemattr_alert_delay();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_delay >&
      itemattr_alert_delay() const;

  // repeated .BatteryConfig.Attributes_alert_release_value ItemAttr_alert_release_value = 8;
  int itemattr_alert_release_value_size() const;
  private:
  int _internal_itemattr_alert_release_value_size() const;
  public:
  void clear_itemattr_alert_release_value();
  ::BatteryConfig::Attributes_alert_release_value* mutable_itemattr_alert_release_value(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_value >*
      mutable_itemattr_alert_release_value();
  private:
  const ::BatteryConfig::Attributes_alert_release_value& _internal_itemattr_alert_release_value(int index) const;
  ::BatteryConfig::Attributes_alert_release_value* _internal_add_itemattr_alert_release_value();
  public:
  const ::BatteryConfig::Attributes_alert_release_value& itemattr_alert_release_value(int index) const;
  ::BatteryConfig::Attributes_alert_release_value* add_itemattr_alert_release_value();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_value >&
      itemattr_alert_release_value() const;

  // repeated .BatteryConfig.Attributes_alert_release_delay ItemAttr_alert_release_delay = 9;
  int itemattr_alert_release_delay_size() const;
  private:
  int _internal_itemattr_alert_release_delay_size() const;
  public:
  void clear_itemattr_alert_release_delay();
  ::BatteryConfig::Attributes_alert_release_delay* mutable_itemattr_alert_release_delay(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_delay >*
      mutable_itemattr_alert_release_delay();
  private:
  const ::BatteryConfig::Attributes_alert_release_delay& _internal_itemattr_alert_release_delay(int index) const;
  ::BatteryConfig::Attributes_alert_release_delay* _internal_add_itemattr_alert_release_delay();
  public:
  const ::BatteryConfig::Attributes_alert_release_delay& itemattr_alert_release_delay(int index) const;
  ::BatteryConfig::Attributes_alert_release_delay* add_itemattr_alert_release_delay();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_delay >&
      itemattr_alert_release_delay() const;

  // repeated .BatteryConfig.Attributes_alert_dropcurr_rate ItemAttr_alert_dropcurr_rate = 10;
  int itemattr_alert_dropcurr_rate_size() const;
  private:
  int _internal_itemattr_alert_dropcurr_rate_size() const;
  public:
  void clear_itemattr_alert_dropcurr_rate();
  ::BatteryConfig::Attributes_alert_dropcurr_rate* mutable_itemattr_alert_dropcurr_rate(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_dropcurr_rate >*
      mutable_itemattr_alert_dropcurr_rate();
  private:
  const ::BatteryConfig::Attributes_alert_dropcurr_rate& _internal_itemattr_alert_dropcurr_rate(int index) const;
  ::BatteryConfig::Attributes_alert_dropcurr_rate* _internal_add_itemattr_alert_dropcurr_rate();
  public:
  const ::BatteryConfig::Attributes_alert_dropcurr_rate& itemattr_alert_dropcurr_rate(int index) const;
  ::BatteryConfig::Attributes_alert_dropcurr_rate* add_itemattr_alert_dropcurr_rate();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_dropcurr_rate >&
      itemattr_alert_dropcurr_rate() const;

  // repeated .BatteryConfig.Attributes_alert_solve_measure ItemAttr_alert_solve_measure = 11;
  int itemattr_alert_solve_measure_size() const;
  private:
  int _internal_itemattr_alert_solve_measure_size() const;
  public:
  void clear_itemattr_alert_solve_measure();
  ::BatteryConfig::Attributes_alert_solve_measure* mutable_itemattr_alert_solve_measure(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_solve_measure >*
      mutable_itemattr_alert_solve_measure();
  private:
  const ::BatteryConfig::Attributes_alert_solve_measure& _internal_itemattr_alert_solve_measure(int index) const;
  ::BatteryConfig::Attributes_alert_solve_measure* _internal_add_itemattr_alert_solve_measure();
  public:
  const ::BatteryConfig::Attributes_alert_solve_measure& itemattr_alert_solve_measure(int index) const;
  ::BatteryConfig::Attributes_alert_solve_measure* add_itemattr_alert_solve_measure();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_solve_measure >&
      itemattr_alert_solve_measure() const;

  // @@protoc_insertion_point(class_scope:BatteryConfig.Item)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes > itemattr_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_balance > itemattr_balance_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_DIDO > itemattr_dido_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_SOX > itemattr_sox_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_other > itemattr_other_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_value > itemattr_alert_value_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_delay > itemattr_alert_delay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_value > itemattr_alert_release_value_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_delay > itemattr_alert_release_delay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_dropcurr_rate > itemattr_alert_dropcurr_rate_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_solve_measure > itemattr_alert_solve_measure_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes& from) {
    Attributes::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_balance* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_balance>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_balance& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_balance& from) {
    Attributes_balance::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_balance)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_DIDO* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_DIDO>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_DIDO& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_DIDO& from) {
    Attributes_DIDO::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_DIDO)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_SOX* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_SOX>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_SOX& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_SOX& from) {
    Attributes_SOX::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_SOX)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_other* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_other>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_other& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_other& from) {
    Attributes_other::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_other)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_value>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_value& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_value& from) {
    Attributes_alert_value::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_value)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_delay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_delay>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_delay& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_delay& from) {
    Attributes_alert_delay::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_delay)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_release_value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_release_value>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_release_value& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_release_value& from) {
    Attributes_alert_release_value::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_release_value)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_release_delay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_release_delay>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_release_delay& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_release_delay& from) {
    Attributes_alert_release_delay::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_release_delay)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_dropcurr_rate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_dropcurr_rate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_dropcurr_rate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_dropcurr_rate& from) {
    Attributes_alert_dropcurr_rate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_dropcurr_rate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Attributes_alert_solve_measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Attributes_alert_solve_measure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Attributes_alert_solve_measure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Attributes_alert_solve_measure& from) {
    Attributes_alert_solve_measure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kIntroduceFieldNumber = 5,
    kAddrFieldNumber = 2,
    kValueFieldNumber = 3,
    kScaleFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string introduce = 5;
  void clear_introduce();
  const std::string& introduce() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_introduce(ArgT0&& arg0, ArgT... args);
  std::string* mutable_introduce();
  PROTOBUF_NODISCARD std::string* release_introduce();
  void set_allocated_introduce(std::string* introduce);
  private:
  const std::string& _internal_introduce() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_introduce(const std::string& value);
  std::string* _internal_mutable_introduce();
  public:

  // int32 addr = 2;
  void clear_addr();
  int32_t addr() const;
  void set_addr(int32_t value);
  private:
  int32_t _internal_addr() const;
  void _internal_set_addr(int32_t value);
  public:

  // int32 value = 3;
  void clear_value();
  int32_t value() const;
  void set_value(int32_t value);
  private:
  int32_t _internal_value() const;
  void _internal_set_value(int32_t value);
  public:

  // float scale = 4;
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

  // @@protoc_insertion_point(class_scope:BatteryConfig.Attributes_alert_solve_measure)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr introduce_;
    int32_t addr_;
    int32_t value_;
    float scale_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_battery_2eproto;
};
// ===================================================================


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

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

// repeated .BatteryConfig.Attributes ItemAttr = 1;
inline int Item::_internal_itemattr_size() const {
  return _impl_.itemattr_.size();
}
inline int Item::itemattr_size() const {
  return _internal_itemattr_size();
}
inline void Item::clear_itemattr() {
  _impl_.itemattr_.Clear();
}
inline ::BatteryConfig::Attributes* Item::mutable_itemattr(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr)
  return _impl_.itemattr_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes >*
Item::mutable_itemattr() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr)
  return &_impl_.itemattr_;
}
inline const ::BatteryConfig::Attributes& Item::_internal_itemattr(int index) const {
  return _impl_.itemattr_.Get(index);
}
inline const ::BatteryConfig::Attributes& Item::itemattr(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr)
  return _internal_itemattr(index);
}
inline ::BatteryConfig::Attributes* Item::_internal_add_itemattr() {
  return _impl_.itemattr_.Add();
}
inline ::BatteryConfig::Attributes* Item::add_itemattr() {
  ::BatteryConfig::Attributes* _add = _internal_add_itemattr();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes >&
Item::itemattr() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr)
  return _impl_.itemattr_;
}

// repeated .BatteryConfig.Attributes_balance ItemAttr_balance = 2;
inline int Item::_internal_itemattr_balance_size() const {
  return _impl_.itemattr_balance_.size();
}
inline int Item::itemattr_balance_size() const {
  return _internal_itemattr_balance_size();
}
inline void Item::clear_itemattr_balance() {
  _impl_.itemattr_balance_.Clear();
}
inline ::BatteryConfig::Attributes_balance* Item::mutable_itemattr_balance(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_balance)
  return _impl_.itemattr_balance_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_balance >*
Item::mutable_itemattr_balance() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_balance)
  return &_impl_.itemattr_balance_;
}
inline const ::BatteryConfig::Attributes_balance& Item::_internal_itemattr_balance(int index) const {
  return _impl_.itemattr_balance_.Get(index);
}
inline const ::BatteryConfig::Attributes_balance& Item::itemattr_balance(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_balance)
  return _internal_itemattr_balance(index);
}
inline ::BatteryConfig::Attributes_balance* Item::_internal_add_itemattr_balance() {
  return _impl_.itemattr_balance_.Add();
}
inline ::BatteryConfig::Attributes_balance* Item::add_itemattr_balance() {
  ::BatteryConfig::Attributes_balance* _add = _internal_add_itemattr_balance();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_balance)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_balance >&
Item::itemattr_balance() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_balance)
  return _impl_.itemattr_balance_;
}

// repeated .BatteryConfig.Attributes_DIDO ItemAttr_DIDO = 3;
inline int Item::_internal_itemattr_dido_size() const {
  return _impl_.itemattr_dido_.size();
}
inline int Item::itemattr_dido_size() const {
  return _internal_itemattr_dido_size();
}
inline void Item::clear_itemattr_dido() {
  _impl_.itemattr_dido_.Clear();
}
inline ::BatteryConfig::Attributes_DIDO* Item::mutable_itemattr_dido(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_DIDO)
  return _impl_.itemattr_dido_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_DIDO >*
Item::mutable_itemattr_dido() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_DIDO)
  return &_impl_.itemattr_dido_;
}
inline const ::BatteryConfig::Attributes_DIDO& Item::_internal_itemattr_dido(int index) const {
  return _impl_.itemattr_dido_.Get(index);
}
inline const ::BatteryConfig::Attributes_DIDO& Item::itemattr_dido(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_DIDO)
  return _internal_itemattr_dido(index);
}
inline ::BatteryConfig::Attributes_DIDO* Item::_internal_add_itemattr_dido() {
  return _impl_.itemattr_dido_.Add();
}
inline ::BatteryConfig::Attributes_DIDO* Item::add_itemattr_dido() {
  ::BatteryConfig::Attributes_DIDO* _add = _internal_add_itemattr_dido();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_DIDO)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_DIDO >&
Item::itemattr_dido() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_DIDO)
  return _impl_.itemattr_dido_;
}

// repeated .BatteryConfig.Attributes_SOX ItemAttr_SOX = 4;
inline int Item::_internal_itemattr_sox_size() const {
  return _impl_.itemattr_sox_.size();
}
inline int Item::itemattr_sox_size() const {
  return _internal_itemattr_sox_size();
}
inline void Item::clear_itemattr_sox() {
  _impl_.itemattr_sox_.Clear();
}
inline ::BatteryConfig::Attributes_SOX* Item::mutable_itemattr_sox(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_SOX)
  return _impl_.itemattr_sox_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_SOX >*
Item::mutable_itemattr_sox() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_SOX)
  return &_impl_.itemattr_sox_;
}
inline const ::BatteryConfig::Attributes_SOX& Item::_internal_itemattr_sox(int index) const {
  return _impl_.itemattr_sox_.Get(index);
}
inline const ::BatteryConfig::Attributes_SOX& Item::itemattr_sox(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_SOX)
  return _internal_itemattr_sox(index);
}
inline ::BatteryConfig::Attributes_SOX* Item::_internal_add_itemattr_sox() {
  return _impl_.itemattr_sox_.Add();
}
inline ::BatteryConfig::Attributes_SOX* Item::add_itemattr_sox() {
  ::BatteryConfig::Attributes_SOX* _add = _internal_add_itemattr_sox();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_SOX)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_SOX >&
Item::itemattr_sox() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_SOX)
  return _impl_.itemattr_sox_;
}

// repeated .BatteryConfig.Attributes_other ItemAttr_other = 5;
inline int Item::_internal_itemattr_other_size() const {
  return _impl_.itemattr_other_.size();
}
inline int Item::itemattr_other_size() const {
  return _internal_itemattr_other_size();
}
inline void Item::clear_itemattr_other() {
  _impl_.itemattr_other_.Clear();
}
inline ::BatteryConfig::Attributes_other* Item::mutable_itemattr_other(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_other)
  return _impl_.itemattr_other_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_other >*
Item::mutable_itemattr_other() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_other)
  return &_impl_.itemattr_other_;
}
inline const ::BatteryConfig::Attributes_other& Item::_internal_itemattr_other(int index) const {
  return _impl_.itemattr_other_.Get(index);
}
inline const ::BatteryConfig::Attributes_other& Item::itemattr_other(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_other)
  return _internal_itemattr_other(index);
}
inline ::BatteryConfig::Attributes_other* Item::_internal_add_itemattr_other() {
  return _impl_.itemattr_other_.Add();
}
inline ::BatteryConfig::Attributes_other* Item::add_itemattr_other() {
  ::BatteryConfig::Attributes_other* _add = _internal_add_itemattr_other();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_other)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_other >&
Item::itemattr_other() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_other)
  return _impl_.itemattr_other_;
}

// repeated .BatteryConfig.Attributes_alert_value ItemAttr_alert_value = 6;
inline int Item::_internal_itemattr_alert_value_size() const {
  return _impl_.itemattr_alert_value_.size();
}
inline int Item::itemattr_alert_value_size() const {
  return _internal_itemattr_alert_value_size();
}
inline void Item::clear_itemattr_alert_value() {
  _impl_.itemattr_alert_value_.Clear();
}
inline ::BatteryConfig::Attributes_alert_value* Item::mutable_itemattr_alert_value(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_value)
  return _impl_.itemattr_alert_value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_value >*
Item::mutable_itemattr_alert_value() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_value)
  return &_impl_.itemattr_alert_value_;
}
inline const ::BatteryConfig::Attributes_alert_value& Item::_internal_itemattr_alert_value(int index) const {
  return _impl_.itemattr_alert_value_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_value& Item::itemattr_alert_value(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_value)
  return _internal_itemattr_alert_value(index);
}
inline ::BatteryConfig::Attributes_alert_value* Item::_internal_add_itemattr_alert_value() {
  return _impl_.itemattr_alert_value_.Add();
}
inline ::BatteryConfig::Attributes_alert_value* Item::add_itemattr_alert_value() {
  ::BatteryConfig::Attributes_alert_value* _add = _internal_add_itemattr_alert_value();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_value)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_value >&
Item::itemattr_alert_value() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_value)
  return _impl_.itemattr_alert_value_;
}

// repeated .BatteryConfig.Attributes_alert_delay ItemAttr_alert_delay = 7;
inline int Item::_internal_itemattr_alert_delay_size() const {
  return _impl_.itemattr_alert_delay_.size();
}
inline int Item::itemattr_alert_delay_size() const {
  return _internal_itemattr_alert_delay_size();
}
inline void Item::clear_itemattr_alert_delay() {
  _impl_.itemattr_alert_delay_.Clear();
}
inline ::BatteryConfig::Attributes_alert_delay* Item::mutable_itemattr_alert_delay(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_delay)
  return _impl_.itemattr_alert_delay_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_delay >*
Item::mutable_itemattr_alert_delay() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_delay)
  return &_impl_.itemattr_alert_delay_;
}
inline const ::BatteryConfig::Attributes_alert_delay& Item::_internal_itemattr_alert_delay(int index) const {
  return _impl_.itemattr_alert_delay_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_delay& Item::itemattr_alert_delay(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_delay)
  return _internal_itemattr_alert_delay(index);
}
inline ::BatteryConfig::Attributes_alert_delay* Item::_internal_add_itemattr_alert_delay() {
  return _impl_.itemattr_alert_delay_.Add();
}
inline ::BatteryConfig::Attributes_alert_delay* Item::add_itemattr_alert_delay() {
  ::BatteryConfig::Attributes_alert_delay* _add = _internal_add_itemattr_alert_delay();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_delay)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_delay >&
Item::itemattr_alert_delay() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_delay)
  return _impl_.itemattr_alert_delay_;
}

// repeated .BatteryConfig.Attributes_alert_release_value ItemAttr_alert_release_value = 8;
inline int Item::_internal_itemattr_alert_release_value_size() const {
  return _impl_.itemattr_alert_release_value_.size();
}
inline int Item::itemattr_alert_release_value_size() const {
  return _internal_itemattr_alert_release_value_size();
}
inline void Item::clear_itemattr_alert_release_value() {
  _impl_.itemattr_alert_release_value_.Clear();
}
inline ::BatteryConfig::Attributes_alert_release_value* Item::mutable_itemattr_alert_release_value(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_release_value)
  return _impl_.itemattr_alert_release_value_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_value >*
Item::mutable_itemattr_alert_release_value() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_release_value)
  return &_impl_.itemattr_alert_release_value_;
}
inline const ::BatteryConfig::Attributes_alert_release_value& Item::_internal_itemattr_alert_release_value(int index) const {
  return _impl_.itemattr_alert_release_value_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_release_value& Item::itemattr_alert_release_value(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_release_value)
  return _internal_itemattr_alert_release_value(index);
}
inline ::BatteryConfig::Attributes_alert_release_value* Item::_internal_add_itemattr_alert_release_value() {
  return _impl_.itemattr_alert_release_value_.Add();
}
inline ::BatteryConfig::Attributes_alert_release_value* Item::add_itemattr_alert_release_value() {
  ::BatteryConfig::Attributes_alert_release_value* _add = _internal_add_itemattr_alert_release_value();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_release_value)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_value >&
Item::itemattr_alert_release_value() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_release_value)
  return _impl_.itemattr_alert_release_value_;
}

// repeated .BatteryConfig.Attributes_alert_release_delay ItemAttr_alert_release_delay = 9;
inline int Item::_internal_itemattr_alert_release_delay_size() const {
  return _impl_.itemattr_alert_release_delay_.size();
}
inline int Item::itemattr_alert_release_delay_size() const {
  return _internal_itemattr_alert_release_delay_size();
}
inline void Item::clear_itemattr_alert_release_delay() {
  _impl_.itemattr_alert_release_delay_.Clear();
}
inline ::BatteryConfig::Attributes_alert_release_delay* Item::mutable_itemattr_alert_release_delay(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_release_delay)
  return _impl_.itemattr_alert_release_delay_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_delay >*
Item::mutable_itemattr_alert_release_delay() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_release_delay)
  return &_impl_.itemattr_alert_release_delay_;
}
inline const ::BatteryConfig::Attributes_alert_release_delay& Item::_internal_itemattr_alert_release_delay(int index) const {
  return _impl_.itemattr_alert_release_delay_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_release_delay& Item::itemattr_alert_release_delay(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_release_delay)
  return _internal_itemattr_alert_release_delay(index);
}
inline ::BatteryConfig::Attributes_alert_release_delay* Item::_internal_add_itemattr_alert_release_delay() {
  return _impl_.itemattr_alert_release_delay_.Add();
}
inline ::BatteryConfig::Attributes_alert_release_delay* Item::add_itemattr_alert_release_delay() {
  ::BatteryConfig::Attributes_alert_release_delay* _add = _internal_add_itemattr_alert_release_delay();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_release_delay)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_release_delay >&
Item::itemattr_alert_release_delay() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_release_delay)
  return _impl_.itemattr_alert_release_delay_;
}

// repeated .BatteryConfig.Attributes_alert_dropcurr_rate ItemAttr_alert_dropcurr_rate = 10;
inline int Item::_internal_itemattr_alert_dropcurr_rate_size() const {
  return _impl_.itemattr_alert_dropcurr_rate_.size();
}
inline int Item::itemattr_alert_dropcurr_rate_size() const {
  return _internal_itemattr_alert_dropcurr_rate_size();
}
inline void Item::clear_itemattr_alert_dropcurr_rate() {
  _impl_.itemattr_alert_dropcurr_rate_.Clear();
}
inline ::BatteryConfig::Attributes_alert_dropcurr_rate* Item::mutable_itemattr_alert_dropcurr_rate(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_dropcurr_rate)
  return _impl_.itemattr_alert_dropcurr_rate_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_dropcurr_rate >*
Item::mutable_itemattr_alert_dropcurr_rate() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_dropcurr_rate)
  return &_impl_.itemattr_alert_dropcurr_rate_;
}
inline const ::BatteryConfig::Attributes_alert_dropcurr_rate& Item::_internal_itemattr_alert_dropcurr_rate(int index) const {
  return _impl_.itemattr_alert_dropcurr_rate_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_dropcurr_rate& Item::itemattr_alert_dropcurr_rate(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_dropcurr_rate)
  return _internal_itemattr_alert_dropcurr_rate(index);
}
inline ::BatteryConfig::Attributes_alert_dropcurr_rate* Item::_internal_add_itemattr_alert_dropcurr_rate() {
  return _impl_.itemattr_alert_dropcurr_rate_.Add();
}
inline ::BatteryConfig::Attributes_alert_dropcurr_rate* Item::add_itemattr_alert_dropcurr_rate() {
  ::BatteryConfig::Attributes_alert_dropcurr_rate* _add = _internal_add_itemattr_alert_dropcurr_rate();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_dropcurr_rate)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_dropcurr_rate >&
Item::itemattr_alert_dropcurr_rate() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_dropcurr_rate)
  return _impl_.itemattr_alert_dropcurr_rate_;
}

// repeated .BatteryConfig.Attributes_alert_solve_measure ItemAttr_alert_solve_measure = 11;
inline int Item::_internal_itemattr_alert_solve_measure_size() const {
  return _impl_.itemattr_alert_solve_measure_.size();
}
inline int Item::itemattr_alert_solve_measure_size() const {
  return _internal_itemattr_alert_solve_measure_size();
}
inline void Item::clear_itemattr_alert_solve_measure() {
  _impl_.itemattr_alert_solve_measure_.Clear();
}
inline ::BatteryConfig::Attributes_alert_solve_measure* Item::mutable_itemattr_alert_solve_measure(int index) {
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Item.ItemAttr_alert_solve_measure)
  return _impl_.itemattr_alert_solve_measure_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_solve_measure >*
Item::mutable_itemattr_alert_solve_measure() {
  // @@protoc_insertion_point(field_mutable_list:BatteryConfig.Item.ItemAttr_alert_solve_measure)
  return &_impl_.itemattr_alert_solve_measure_;
}
inline const ::BatteryConfig::Attributes_alert_solve_measure& Item::_internal_itemattr_alert_solve_measure(int index) const {
  return _impl_.itemattr_alert_solve_measure_.Get(index);
}
inline const ::BatteryConfig::Attributes_alert_solve_measure& Item::itemattr_alert_solve_measure(int index) const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Item.ItemAttr_alert_solve_measure)
  return _internal_itemattr_alert_solve_measure(index);
}
inline ::BatteryConfig::Attributes_alert_solve_measure* Item::_internal_add_itemattr_alert_solve_measure() {
  return _impl_.itemattr_alert_solve_measure_.Add();
}
inline ::BatteryConfig::Attributes_alert_solve_measure* Item::add_itemattr_alert_solve_measure() {
  ::BatteryConfig::Attributes_alert_solve_measure* _add = _internal_add_itemattr_alert_solve_measure();
  // @@protoc_insertion_point(field_add:BatteryConfig.Item.ItemAttr_alert_solve_measure)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::BatteryConfig::Attributes_alert_solve_measure >&
Item::itemattr_alert_solve_measure() const {
  // @@protoc_insertion_point(field_list:BatteryConfig.Item.ItemAttr_alert_solve_measure)
  return _impl_.itemattr_alert_solve_measure_;
}

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

// Attributes

// string name = 1;
inline void Attributes::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes.name)
}
inline std::string* Attributes::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes.name)
  return _s;
}
inline const std::string& Attributes::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes.name)
  return _impl_.name_.Release();
}
inline void Attributes::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes.name)
}

// int32 addr = 2;
inline void Attributes::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes.addr)
  return _internal_addr();
}
inline void Attributes::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes.addr)
}

// int32 value = 3;
inline void Attributes::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes.value)
  return _internal_value();
}
inline void Attributes::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes.value)
}

// float scale = 4;
inline void Attributes::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes.scale)
  return _internal_scale();
}
inline void Attributes::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes.scale)
}

// string introduce = 5;
inline void Attributes::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes.introduce)
}
inline std::string* Attributes::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes.introduce)
  return _s;
}
inline const std::string& Attributes::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes.introduce)
}

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

// Attributes_balance

// string name = 1;
inline void Attributes_balance::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_balance::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_balance.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_balance::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_balance.name)
}
inline std::string* Attributes_balance::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_balance.name)
  return _s;
}
inline const std::string& Attributes_balance::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_balance::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_balance::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_balance::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_balance.name)
  return _impl_.name_.Release();
}
inline void Attributes_balance::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_balance.name)
}

// int32 addr = 2;
inline void Attributes_balance::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_balance::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_balance::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_balance.addr)
  return _internal_addr();
}
inline void Attributes_balance::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_balance::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_balance.addr)
}

// int32 value = 3;
inline void Attributes_balance::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_balance::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_balance::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_balance.value)
  return _internal_value();
}
inline void Attributes_balance::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_balance::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_balance.value)
}

// float scale = 4;
inline void Attributes_balance::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_balance::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_balance::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_balance.scale)
  return _internal_scale();
}
inline void Attributes_balance::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_balance::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_balance.scale)
}

// string introduce = 5;
inline void Attributes_balance::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_balance::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_balance.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_balance::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_balance.introduce)
}
inline std::string* Attributes_balance::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_balance.introduce)
  return _s;
}
inline const std::string& Attributes_balance::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_balance::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_balance::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_balance::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_balance.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_balance::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_balance.introduce)
}

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

// Attributes_DIDO

// string name = 1;
inline void Attributes_DIDO::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_DIDO::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_DIDO.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_DIDO::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_DIDO.name)
}
inline std::string* Attributes_DIDO::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_DIDO.name)
  return _s;
}
inline const std::string& Attributes_DIDO::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_DIDO::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_DIDO::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_DIDO::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_DIDO.name)
  return _impl_.name_.Release();
}
inline void Attributes_DIDO::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_DIDO.name)
}

// int32 addr = 2;
inline void Attributes_DIDO::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_DIDO::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_DIDO::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_DIDO.addr)
  return _internal_addr();
}
inline void Attributes_DIDO::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_DIDO::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_DIDO.addr)
}

// int32 value = 3;
inline void Attributes_DIDO::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_DIDO::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_DIDO::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_DIDO.value)
  return _internal_value();
}
inline void Attributes_DIDO::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_DIDO::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_DIDO.value)
}

// float scale = 4;
inline void Attributes_DIDO::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_DIDO::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_DIDO::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_DIDO.scale)
  return _internal_scale();
}
inline void Attributes_DIDO::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_DIDO::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_DIDO.scale)
}

// string introduce = 5;
inline void Attributes_DIDO::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_DIDO::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_DIDO.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_DIDO::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_DIDO.introduce)
}
inline std::string* Attributes_DIDO::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_DIDO.introduce)
  return _s;
}
inline const std::string& Attributes_DIDO::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_DIDO::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_DIDO::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_DIDO::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_DIDO.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_DIDO::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_DIDO.introduce)
}

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

// Attributes_SOX

// string name = 1;
inline void Attributes_SOX::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_SOX::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_SOX.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_SOX::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_SOX.name)
}
inline std::string* Attributes_SOX::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_SOX.name)
  return _s;
}
inline const std::string& Attributes_SOX::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_SOX::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_SOX::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_SOX::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_SOX.name)
  return _impl_.name_.Release();
}
inline void Attributes_SOX::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_SOX.name)
}

// int32 addr = 2;
inline void Attributes_SOX::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_SOX::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_SOX::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_SOX.addr)
  return _internal_addr();
}
inline void Attributes_SOX::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_SOX::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_SOX.addr)
}

// int32 value = 3;
inline void Attributes_SOX::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_SOX::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_SOX::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_SOX.value)
  return _internal_value();
}
inline void Attributes_SOX::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_SOX::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_SOX.value)
}

// float scale = 4;
inline void Attributes_SOX::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_SOX::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_SOX::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_SOX.scale)
  return _internal_scale();
}
inline void Attributes_SOX::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_SOX::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_SOX.scale)
}

// string introduce = 5;
inline void Attributes_SOX::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_SOX::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_SOX.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_SOX::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_SOX.introduce)
}
inline std::string* Attributes_SOX::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_SOX.introduce)
  return _s;
}
inline const std::string& Attributes_SOX::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_SOX::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_SOX::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_SOX::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_SOX.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_SOX::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_SOX.introduce)
}

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

// Attributes_other

// string name = 1;
inline void Attributes_other::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_other::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_other.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_other::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_other.name)
}
inline std::string* Attributes_other::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_other.name)
  return _s;
}
inline const std::string& Attributes_other::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_other::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_other::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_other::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_other.name)
  return _impl_.name_.Release();
}
inline void Attributes_other::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_other.name)
}

// int32 addr = 2;
inline void Attributes_other::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_other::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_other::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_other.addr)
  return _internal_addr();
}
inline void Attributes_other::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_other::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_other.addr)
}

// int32 value = 3;
inline void Attributes_other::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_other::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_other::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_other.value)
  return _internal_value();
}
inline void Attributes_other::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_other::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_other.value)
}

// float scale = 4;
inline void Attributes_other::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_other::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_other::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_other.scale)
  return _internal_scale();
}
inline void Attributes_other::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_other::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_other.scale)
}

// string introduce = 5;
inline void Attributes_other::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_other::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_other.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_other::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_other.introduce)
}
inline std::string* Attributes_other::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_other.introduce)
  return _s;
}
inline const std::string& Attributes_other::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_other::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_other::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_other::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_other.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_other::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_other.introduce)
}

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

// Attributes_alert_value

// string name = 1;
inline void Attributes_alert_value::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_value::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_value.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_value::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_value.name)
}
inline std::string* Attributes_alert_value::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_value.name)
  return _s;
}
inline const std::string& Attributes_alert_value::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_value::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_value::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_value::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_value.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_value::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_value.name)
}

// int32 addr = 2;
inline void Attributes_alert_value::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_value::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_value::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_value.addr)
  return _internal_addr();
}
inline void Attributes_alert_value::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_value::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_value.addr)
}

// int32 value = 3;
inline void Attributes_alert_value::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_value::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_value::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_value.value)
  return _internal_value();
}
inline void Attributes_alert_value::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_value::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_value.value)
}

// float scale = 4;
inline void Attributes_alert_value::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_value::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_value::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_value.scale)
  return _internal_scale();
}
inline void Attributes_alert_value::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_value::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_value.scale)
}

// string introduce = 5;
inline void Attributes_alert_value::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_value::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_value.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_value::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_value.introduce)
}
inline std::string* Attributes_alert_value::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_value.introduce)
  return _s;
}
inline const std::string& Attributes_alert_value::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_value::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_value::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_value::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_value.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_value::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_value.introduce)
}

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

// Attributes_alert_delay

// string name = 1;
inline void Attributes_alert_delay::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_delay::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_delay.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_delay::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_delay.name)
}
inline std::string* Attributes_alert_delay::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_delay.name)
  return _s;
}
inline const std::string& Attributes_alert_delay::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_delay::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_delay::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_delay::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_delay.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_delay::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_delay.name)
}

// int32 addr = 2;
inline void Attributes_alert_delay::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_delay::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_delay::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_delay.addr)
  return _internal_addr();
}
inline void Attributes_alert_delay::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_delay::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_delay.addr)
}

// int32 value = 3;
inline void Attributes_alert_delay::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_delay::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_delay::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_delay.value)
  return _internal_value();
}
inline void Attributes_alert_delay::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_delay::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_delay.value)
}

// float scale = 4;
inline void Attributes_alert_delay::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_delay::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_delay::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_delay.scale)
  return _internal_scale();
}
inline void Attributes_alert_delay::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_delay::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_delay.scale)
}

// string introduce = 5;
inline void Attributes_alert_delay::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_delay::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_delay.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_delay::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_delay.introduce)
}
inline std::string* Attributes_alert_delay::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_delay.introduce)
  return _s;
}
inline const std::string& Attributes_alert_delay::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_delay::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_delay::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_delay::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_delay.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_delay::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_delay.introduce)
}

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

// Attributes_alert_release_value

// string name = 1;
inline void Attributes_alert_release_value::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_release_value::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_value.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_release_value::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_value.name)
}
inline std::string* Attributes_alert_release_value::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_release_value.name)
  return _s;
}
inline const std::string& Attributes_alert_release_value::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_release_value::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_value::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_value::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_release_value.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_release_value::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_release_value.name)
}

// int32 addr = 2;
inline void Attributes_alert_release_value::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_release_value::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_release_value::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_value.addr)
  return _internal_addr();
}
inline void Attributes_alert_release_value::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_release_value::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_value.addr)
}

// int32 value = 3;
inline void Attributes_alert_release_value::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_release_value::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_release_value::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_value.value)
  return _internal_value();
}
inline void Attributes_alert_release_value::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_release_value::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_value.value)
}

// float scale = 4;
inline void Attributes_alert_release_value::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_release_value::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_release_value::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_value.scale)
  return _internal_scale();
}
inline void Attributes_alert_release_value::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_release_value::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_value.scale)
}

// string introduce = 5;
inline void Attributes_alert_release_value::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_release_value::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_value.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_release_value::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_value.introduce)
}
inline std::string* Attributes_alert_release_value::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_release_value.introduce)
  return _s;
}
inline const std::string& Attributes_alert_release_value::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_release_value::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_value::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_value::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_release_value.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_release_value::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_release_value.introduce)
}

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

// Attributes_alert_release_delay

// string name = 1;
inline void Attributes_alert_release_delay::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_release_delay::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_delay.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_release_delay::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_delay.name)
}
inline std::string* Attributes_alert_release_delay::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_release_delay.name)
  return _s;
}
inline const std::string& Attributes_alert_release_delay::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_release_delay::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_delay::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_delay::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_release_delay.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_release_delay::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_release_delay.name)
}

// int32 addr = 2;
inline void Attributes_alert_release_delay::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_release_delay::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_release_delay::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_delay.addr)
  return _internal_addr();
}
inline void Attributes_alert_release_delay::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_release_delay::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_delay.addr)
}

// int32 value = 3;
inline void Attributes_alert_release_delay::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_release_delay::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_release_delay::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_delay.value)
  return _internal_value();
}
inline void Attributes_alert_release_delay::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_release_delay::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_delay.value)
}

// float scale = 4;
inline void Attributes_alert_release_delay::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_release_delay::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_release_delay::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_delay.scale)
  return _internal_scale();
}
inline void Attributes_alert_release_delay::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_release_delay::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_delay.scale)
}

// string introduce = 5;
inline void Attributes_alert_release_delay::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_release_delay::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_release_delay.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_release_delay::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_release_delay.introduce)
}
inline std::string* Attributes_alert_release_delay::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_release_delay.introduce)
  return _s;
}
inline const std::string& Attributes_alert_release_delay::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_release_delay::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_delay::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_release_delay::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_release_delay.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_release_delay::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_release_delay.introduce)
}

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

// Attributes_alert_dropcurr_rate

// string name = 1;
inline void Attributes_alert_dropcurr_rate::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_dropcurr_rate::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_dropcurr_rate.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_dropcurr_rate::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_dropcurr_rate.name)
}
inline std::string* Attributes_alert_dropcurr_rate::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_dropcurr_rate.name)
  return _s;
}
inline const std::string& Attributes_alert_dropcurr_rate::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_dropcurr_rate::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_dropcurr_rate::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_dropcurr_rate::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_dropcurr_rate.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_dropcurr_rate::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_dropcurr_rate.name)
}

// int32 addr = 2;
inline void Attributes_alert_dropcurr_rate::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_dropcurr_rate::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_dropcurr_rate::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_dropcurr_rate.addr)
  return _internal_addr();
}
inline void Attributes_alert_dropcurr_rate::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_dropcurr_rate::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_dropcurr_rate.addr)
}

// int32 value = 3;
inline void Attributes_alert_dropcurr_rate::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_dropcurr_rate::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_dropcurr_rate::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_dropcurr_rate.value)
  return _internal_value();
}
inline void Attributes_alert_dropcurr_rate::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_dropcurr_rate::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_dropcurr_rate.value)
}

// float scale = 4;
inline void Attributes_alert_dropcurr_rate::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_dropcurr_rate::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_dropcurr_rate::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_dropcurr_rate.scale)
  return _internal_scale();
}
inline void Attributes_alert_dropcurr_rate::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_dropcurr_rate::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_dropcurr_rate.scale)
}

// string introduce = 5;
inline void Attributes_alert_dropcurr_rate::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_dropcurr_rate::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_dropcurr_rate.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_dropcurr_rate::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_dropcurr_rate.introduce)
}
inline std::string* Attributes_alert_dropcurr_rate::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_dropcurr_rate.introduce)
  return _s;
}
inline const std::string& Attributes_alert_dropcurr_rate::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_dropcurr_rate::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_dropcurr_rate::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_dropcurr_rate::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_dropcurr_rate.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_dropcurr_rate::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_dropcurr_rate.introduce)
}

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

// Attributes_alert_solve_measure

// string name = 1;
inline void Attributes_alert_solve_measure::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Attributes_alert_solve_measure::name() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_solve_measure.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_solve_measure::set_name(ArgT0&& arg0, ArgT... args) {
 
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_solve_measure.name)
}
inline std::string* Attributes_alert_solve_measure::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_solve_measure.name)
  return _s;
}
inline const std::string& Attributes_alert_solve_measure::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Attributes_alert_solve_measure::_internal_set_name(const std::string& value) {
  
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_solve_measure::_internal_mutable_name() {
  
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_solve_measure::release_name() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_solve_measure.name)
  return _impl_.name_.Release();
}
inline void Attributes_alert_solve_measure::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_solve_measure.name)
}

// int32 addr = 2;
inline void Attributes_alert_solve_measure::clear_addr() {
  _impl_.addr_ = 0;
}
inline int32_t Attributes_alert_solve_measure::_internal_addr() const {
  return _impl_.addr_;
}
inline int32_t Attributes_alert_solve_measure::addr() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_solve_measure.addr)
  return _internal_addr();
}
inline void Attributes_alert_solve_measure::_internal_set_addr(int32_t value) {
  
  _impl_.addr_ = value;
}
inline void Attributes_alert_solve_measure::set_addr(int32_t value) {
  _internal_set_addr(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_solve_measure.addr)
}

// int32 value = 3;
inline void Attributes_alert_solve_measure::clear_value() {
  _impl_.value_ = 0;
}
inline int32_t Attributes_alert_solve_measure::_internal_value() const {
  return _impl_.value_;
}
inline int32_t Attributes_alert_solve_measure::value() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_solve_measure.value)
  return _internal_value();
}
inline void Attributes_alert_solve_measure::_internal_set_value(int32_t value) {
  
  _impl_.value_ = value;
}
inline void Attributes_alert_solve_measure::set_value(int32_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_solve_measure.value)
}

// float scale = 4;
inline void Attributes_alert_solve_measure::clear_scale() {
  _impl_.scale_ = 0;
}
inline float Attributes_alert_solve_measure::_internal_scale() const {
  return _impl_.scale_;
}
inline float Attributes_alert_solve_measure::scale() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_solve_measure.scale)
  return _internal_scale();
}
inline void Attributes_alert_solve_measure::_internal_set_scale(float value) {
  
  _impl_.scale_ = value;
}
inline void Attributes_alert_solve_measure::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_solve_measure.scale)
}

// string introduce = 5;
inline void Attributes_alert_solve_measure::clear_introduce() {
  _impl_.introduce_.ClearToEmpty();
}
inline const std::string& Attributes_alert_solve_measure::introduce() const {
  // @@protoc_insertion_point(field_get:BatteryConfig.Attributes_alert_solve_measure.introduce)
  return _internal_introduce();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Attributes_alert_solve_measure::set_introduce(ArgT0&& arg0, ArgT... args) {
 
 _impl_.introduce_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:BatteryConfig.Attributes_alert_solve_measure.introduce)
}
inline std::string* Attributes_alert_solve_measure::mutable_introduce() {
  std::string* _s = _internal_mutable_introduce();
  // @@protoc_insertion_point(field_mutable:BatteryConfig.Attributes_alert_solve_measure.introduce)
  return _s;
}
inline const std::string& Attributes_alert_solve_measure::_internal_introduce() const {
  return _impl_.introduce_.Get();
}
inline void Attributes_alert_solve_measure::_internal_set_introduce(const std::string& value) {
  
  _impl_.introduce_.Set(value, GetArenaForAllocation());
}
inline std::string* Attributes_alert_solve_measure::_internal_mutable_introduce() {
  
  return _impl_.introduce_.Mutable(GetArenaForAllocation());
}
inline std::string* Attributes_alert_solve_measure::release_introduce() {
  // @@protoc_insertion_point(field_release:BatteryConfig.Attributes_alert_solve_measure.introduce)
  return _impl_.introduce_.Release();
}
inline void Attributes_alert_solve_measure::set_allocated_introduce(std::string* introduce) {
  if (introduce != nullptr) {
    
  } else {
    
  }
  _impl_.introduce_.SetAllocated(introduce, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.introduce_.IsDefault()) {
    _impl_.introduce_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:BatteryConfig.Attributes_alert_solve_measure.introduce)
}

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace BatteryConfig

// @@protoc_insertion_point(global_scope)

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