nanopb.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: nanopb.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_nanopb_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_nanopb_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/descriptor.pb.h>
#include <boost/units/quantity.hpp>
#include <boost/units/absolute.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/make_scaled_unit.hpp>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_nanopb_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE
 
// Internal implementation detail -- do not use these members.
struct TableStruct_nanopb_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_nanopb_2eproto;
class NanoPBOptions;
struct NanoPBOptionsDefaultTypeInternal;
extern NanoPBOptionsDefaultTypeInternal _NanoPBOptions_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::NanoPBOptions* Arena::CreateMaybeMessage<::NanoPBOptions>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
 
enum FieldType : int {
  FT_DEFAULT = 0,
  FT_CALLBACK = 1,
  FT_POINTER = 4,
  FT_STATIC = 2,
  FT_IGNORE = 3,
  FT_INLINE = 5
};
bool FieldType_IsValid(int value);
constexpr FieldType FieldType_MIN = FT_DEFAULT;
constexpr FieldType FieldType_MAX = FT_INLINE;
constexpr int FieldType_ARRAYSIZE = FieldType_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldType_descriptor();
template<typename T>
inline const std::string& FieldType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, FieldType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function FieldType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    FieldType_descriptor(), enum_t_value);
}
inline bool FieldType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldType>(
    FieldType_descriptor(), name, value);
}
enum IntSize : int {
  IS_DEFAULT = 0,
  IS_8 = 8,
  IS_16 = 16,
  IS_32 = 32,
  IS_64 = 64
};
bool IntSize_IsValid(int value);
constexpr IntSize IntSize_MIN = IS_DEFAULT;
constexpr IntSize IntSize_MAX = IS_64;
constexpr int IntSize_ARRAYSIZE = IntSize_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IntSize_descriptor();
template<typename T>
inline const std::string& IntSize_Name(T enum_t_value) {
  static_assert(::std::is_same<T, IntSize>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function IntSize_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    IntSize_descriptor(), enum_t_value);
}
inline bool IntSize_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IntSize* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IntSize>(
    IntSize_descriptor(), name, value);
}
enum TypenameMangling : int {
  M_NONE = 0,
  M_STRIP_PACKAGE = 1,
  M_FLATTEN = 2,
  M_PACKAGE_INITIALS = 3
};
bool TypenameMangling_IsValid(int value);
constexpr TypenameMangling TypenameMangling_MIN = M_NONE;
constexpr TypenameMangling TypenameMangling_MAX = M_PACKAGE_INITIALS;
constexpr int TypenameMangling_ARRAYSIZE = TypenameMangling_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TypenameMangling_descriptor();
template<typename T>
inline const std::string& TypenameMangling_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TypenameMangling>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TypenameMangling_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TypenameMangling_descriptor(), enum_t_value);
}
inline bool TypenameMangling_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TypenameMangling* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TypenameMangling>(
    TypenameMangling_descriptor(), name, value);
}
enum DescriptorSize : int {
  DS_AUTO = 0,
  DS_1 = 1,
  DS_2 = 2,
  DS_4 = 4,
  DS_8 = 8
};
bool DescriptorSize_IsValid(int value);
constexpr DescriptorSize DescriptorSize_MIN = DS_AUTO;
constexpr DescriptorSize DescriptorSize_MAX = DS_8;
constexpr int DescriptorSize_ARRAYSIZE = DescriptorSize_MAX + 1;
 
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DescriptorSize_descriptor();
template<typename T>
inline const std::string& DescriptorSize_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DescriptorSize>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DescriptorSize_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DescriptorSize_descriptor(), enum_t_value);
}
inline bool DescriptorSize_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DescriptorSize* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DescriptorSize>(
    DescriptorSize_descriptor(), name, value);
}
// ===================================================================
 
class NanoPBOptions final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NanoPBOptions) */ {
 public:
  inline NanoPBOptions() : NanoPBOptions(nullptr) {}
  ~NanoPBOptions() override;
  explicit PROTOBUF_CONSTEXPR NanoPBOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  NanoPBOptions(const NanoPBOptions& from);
  NanoPBOptions(NanoPBOptions&& from) noexcept
    : NanoPBOptions() {
    *this = ::std::move(from);
  }
 
  inline NanoPBOptions& operator=(const NanoPBOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline NanoPBOptions& operator=(NanoPBOptions&& 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;
  }
 
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
 
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NanoPBOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const NanoPBOptions* internal_default_instance() {
    return reinterpret_cast<const NanoPBOptions*>(
               &_NanoPBOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;
 
  friend void swap(NanoPBOptions& a, NanoPBOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(NanoPBOptions* 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(NanoPBOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  NanoPBOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NanoPBOptions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NanoPBOptions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NanoPBOptions& from) {
    NanoPBOptions::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(NanoPBOptions* other);
 
  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NanoPBOptions";
  }
  protected:
  explicit NanoPBOptions(::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 {
    kIncludeFieldNumber = 24,
    kExcludeFieldNumber = 26,
    kCallbackDatatypeFieldNumber = 18,
    kCallbackFunctionFieldNumber = 19,
    kPackageFieldNumber = 25,
    kInitializerFieldNumber = 30,
    kMaxSizeFieldNumber = 1,
    kMaxCountFieldNumber = 2,
    kTypeFieldNumber = 3,
    kIntSizeFieldNumber = 7,
    kPackedStructFieldNumber = 5,
    kPackedEnumFieldNumber = 10,
    kSkipMessageFieldNumber = 6,
    kNoUnionsFieldNumber = 8,
    kMsgidFieldNumber = 9,
    kMaxLengthFieldNumber = 14,
    kAnonymousOneofFieldNumber = 11,
    kProto3FieldNumber = 12,
    kProto3SingularMsgsFieldNumber = 21,
    kEnumToStringFieldNumber = 13,
    kMangleNamesFieldNumber = 17,
    kFixedLengthFieldNumber = 15,
    kFixedCountFieldNumber = 16,
    kSubmsgCallbackFieldNumber = 22,
    kDefaultHasFieldNumber = 23,
    kDescriptorsizeFieldNumber = 20,
    kFallbackTypeFieldNumber = 29,
    kLongNamesFieldNumber = 4,
    kSortByTagFieldNumber = 28,
    kTypeOverrideFieldNumber = 27,
  };
  // repeated string include = 24;
  int include_size() const;
  private:
  int _internal_include_size() const;
  public:
  void clear_include();
  const std::string& include(int index) const;
  std::string* mutable_include(int index);
  void set_include(int index, const std::string& value);
  void set_include(int index, std::string&& value);
  void set_include(int index, const char* value);
  void set_include(int index, const char* value, size_t size);
  std::string* add_include();
  void add_include(const std::string& value);
  void add_include(std::string&& value);
  void add_include(const char* value);
  void add_include(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& include() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_include();
  private:
  const std::string& _internal_include(int index) const;
  std::string* _internal_add_include();
  public:
 
  // repeated string exclude = 26;
  int exclude_size() const;
  private:
  int _internal_exclude_size() const;
  public:
  void clear_exclude();
  const std::string& exclude(int index) const;
  std::string* mutable_exclude(int index);
  void set_exclude(int index, const std::string& value);
  void set_exclude(int index, std::string&& value);
  void set_exclude(int index, const char* value);
  void set_exclude(int index, const char* value, size_t size);
  std::string* add_exclude();
  void add_exclude(const std::string& value);
  void add_exclude(std::string&& value);
  void add_exclude(const char* value);
  void add_exclude(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& exclude() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_exclude();
  private:
  const std::string& _internal_exclude(int index) const;
  std::string* _internal_add_exclude();
  public:
 
  // optional string callback_datatype = 18 [default = "pb_callback_t"];
  bool has_callback_datatype() const;
  private:
  bool _internal_has_callback_datatype() const;
  public:
  void clear_callback_datatype();
  const std::string& callback_datatype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_callback_datatype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_callback_datatype();
  PROTOBUF_NODISCARD std::string* release_callback_datatype();
  void set_allocated_callback_datatype(std::string* callback_datatype);
  private:
  const std::string& _internal_callback_datatype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callback_datatype(const std::string& value);
  std::string* _internal_mutable_callback_datatype();
  public:
 
  // optional string callback_function = 19 [default = "pb_default_field_callback"];
  bool has_callback_function() const;
  private:
  bool _internal_has_callback_function() const;
  public:
  void clear_callback_function();
  const std::string& callback_function() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_callback_function(ArgT0&& arg0, ArgT... args);
  std::string* mutable_callback_function();
  PROTOBUF_NODISCARD std::string* release_callback_function();
  void set_allocated_callback_function(std::string* callback_function);
  private:
  const std::string& _internal_callback_function() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callback_function(const std::string& value);
  std::string* _internal_mutable_callback_function();
  public:
 
  // optional string package = 25;
  bool has_package() const;
  private:
  bool _internal_has_package() const;
  public:
  void clear_package();
  const std::string& package() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_package(ArgT0&& arg0, ArgT... args);
  std::string* mutable_package();
  PROTOBUF_NODISCARD std::string* release_package();
  void set_allocated_package(std::string* package);
  private:
  const std::string& _internal_package() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_package(const std::string& value);
  std::string* _internal_mutable_package();
  public:
 
  // optional string initializer = 30;
  bool has_initializer() const;
  private:
  bool _internal_has_initializer() const;
  public:
  void clear_initializer();
  const std::string& initializer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_initializer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_initializer();
  PROTOBUF_NODISCARD std::string* release_initializer();
  void set_allocated_initializer(std::string* initializer);
  private:
  const std::string& _internal_initializer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_initializer(const std::string& value);
  std::string* _internal_mutable_initializer();
  public:
 
  // optional int32 max_size = 1;
  bool has_max_size() const;
  private:
  bool _internal_has_max_size() const;
  public:
  void clear_max_size();
  int32_t max_size() const;
  void set_max_size(int32_t value);
  private:
  int32_t _internal_max_size() const;
  void _internal_set_max_size(int32_t value);
  public:
 
  // optional int32 max_count = 2;
  bool has_max_count() const;
  private:
  bool _internal_has_max_count() const;
  public:
  void clear_max_count();
  int32_t max_count() const;
  void set_max_count(int32_t value);
  private:
  int32_t _internal_max_count() const;
  void _internal_set_max_count(int32_t value);
  public:
 
  // optional .FieldType type = 3 [default = FT_DEFAULT];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::FieldType type() const;
  void set_type(::FieldType value);
  private:
  ::FieldType _internal_type() const;
  void _internal_set_type(::FieldType value);
  public:
 
  // optional .IntSize int_size = 7 [default = IS_DEFAULT];
  bool has_int_size() const;
  private:
  bool _internal_has_int_size() const;
  public:
  void clear_int_size();
  ::IntSize int_size() const;
  void set_int_size(::IntSize value);
  private:
  ::IntSize _internal_int_size() const;
  void _internal_set_int_size(::IntSize value);
  public:
 
  // optional bool packed_struct = 5 [default = false];
  bool has_packed_struct() const;
  private:
  bool _internal_has_packed_struct() const;
  public:
  void clear_packed_struct();
  bool packed_struct() const;
  void set_packed_struct(bool value);
  private:
  bool _internal_packed_struct() const;
  void _internal_set_packed_struct(bool value);
  public:
 
  // optional bool packed_enum = 10 [default = false];
  bool has_packed_enum() const;
  private:
  bool _internal_has_packed_enum() const;
  public:
  void clear_packed_enum();
  bool packed_enum() const;
  void set_packed_enum(bool value);
  private:
  bool _internal_packed_enum() const;
  void _internal_set_packed_enum(bool value);
  public:
 
  // optional bool skip_message = 6 [default = false];
  bool has_skip_message() const;
  private:
  bool _internal_has_skip_message() const;
  public:
  void clear_skip_message();
  bool skip_message() const;
  void set_skip_message(bool value);
  private:
  bool _internal_skip_message() const;
  void _internal_set_skip_message(bool value);
  public:
 
  // optional bool no_unions = 8 [default = false];
  bool has_no_unions() const;
  private:
  bool _internal_has_no_unions() const;
  public:
  void clear_no_unions();
  bool no_unions() const;
  void set_no_unions(bool value);
  private:
  bool _internal_no_unions() const;
  void _internal_set_no_unions(bool value);
  public:
 
  // optional uint32 msgid = 9;
  bool has_msgid() const;
  private:
  bool _internal_has_msgid() const;
  public:
  void clear_msgid();
  uint32_t msgid() const;
  void set_msgid(uint32_t value);
  private:
  uint32_t _internal_msgid() const;
  void _internal_set_msgid(uint32_t value);
  public:
 
  // optional int32 max_length = 14;
  bool has_max_length() const;
  private:
  bool _internal_has_max_length() const;
  public:
  void clear_max_length();
  int32_t max_length() const;
  void set_max_length(int32_t value);
  private:
  int32_t _internal_max_length() const;
  void _internal_set_max_length(int32_t value);
  public:
 
  // optional bool anonymous_oneof = 11 [default = false];
  bool has_anonymous_oneof() const;
  private:
  bool _internal_has_anonymous_oneof() const;
  public:
  void clear_anonymous_oneof();
  bool anonymous_oneof() const;
  void set_anonymous_oneof(bool value);
  private:
  bool _internal_anonymous_oneof() const;
  void _internal_set_anonymous_oneof(bool value);
  public:
 
  // optional bool proto3 = 12 [default = false];
  bool has_proto3() const;
  private:
  bool _internal_has_proto3() const;
  public:
  void clear_proto3();
  bool proto3() const;
  void set_proto3(bool value);
  private:
  bool _internal_proto3() const;
  void _internal_set_proto3(bool value);
  public:
 
  // optional bool proto3_singular_msgs = 21 [default = false];
  bool has_proto3_singular_msgs() const;
  private:
  bool _internal_has_proto3_singular_msgs() const;
  public:
  void clear_proto3_singular_msgs();
  bool proto3_singular_msgs() const;
  void set_proto3_singular_msgs(bool value);
  private:
  bool _internal_proto3_singular_msgs() const;
  void _internal_set_proto3_singular_msgs(bool value);
  public:
 
  // optional bool enum_to_string = 13 [default = false];
  bool has_enum_to_string() const;
  private:
  bool _internal_has_enum_to_string() const;
  public:
  void clear_enum_to_string();
  bool enum_to_string() const;
  void set_enum_to_string(bool value);
  private:
  bool _internal_enum_to_string() const;
  void _internal_set_enum_to_string(bool value);
  public:
 
  // optional .TypenameMangling mangle_names = 17 [default = M_NONE];
  bool has_mangle_names() const;
  private:
  bool _internal_has_mangle_names() const;
  public:
  void clear_mangle_names();
  ::TypenameMangling mangle_names() const;
  void set_mangle_names(::TypenameMangling value);
  private:
  ::TypenameMangling _internal_mangle_names() const;
  void _internal_set_mangle_names(::TypenameMangling value);
  public:
 
  // optional bool fixed_length = 15 [default = false];
  bool has_fixed_length() const;
  private:
  bool _internal_has_fixed_length() const;
  public:
  void clear_fixed_length();
  bool fixed_length() const;
  void set_fixed_length(bool value);
  private:
  bool _internal_fixed_length() const;
  void _internal_set_fixed_length(bool value);
  public:
 
  // optional bool fixed_count = 16 [default = false];
  bool has_fixed_count() const;
  private:
  bool _internal_has_fixed_count() const;
  public:
  void clear_fixed_count();
  bool fixed_count() const;
  void set_fixed_count(bool value);
  private:
  bool _internal_fixed_count() const;
  void _internal_set_fixed_count(bool value);
  public:
 
  // optional bool submsg_callback = 22 [default = false];
  bool has_submsg_callback() const;
  private:
  bool _internal_has_submsg_callback() const;
  public:
  void clear_submsg_callback();
  bool submsg_callback() const;
  void set_submsg_callback(bool value);
  private:
  bool _internal_submsg_callback() const;
  void _internal_set_submsg_callback(bool value);
  public:
 
  // optional bool default_has = 23 [default = false];
  bool has_default_has() const;
  private:
  bool _internal_has_default_has() const;
  public:
  void clear_default_has();
  bool default_has() const;
  void set_default_has(bool value);
  private:
  bool _internal_default_has() const;
  void _internal_set_default_has(bool value);
  public:
 
  // optional .DescriptorSize descriptorsize = 20 [default = DS_AUTO];
  bool has_descriptorsize() const;
  private:
  bool _internal_has_descriptorsize() const;
  public:
  void clear_descriptorsize();
  ::DescriptorSize descriptorsize() const;
  void set_descriptorsize(::DescriptorSize value);
  private:
  ::DescriptorSize _internal_descriptorsize() const;
  void _internal_set_descriptorsize(::DescriptorSize value);
  public:
 
  // optional .FieldType fallback_type = 29 [default = FT_CALLBACK];
  bool has_fallback_type() const;
  private:
  bool _internal_has_fallback_type() const;
  public:
  void clear_fallback_type();
  ::FieldType fallback_type() const;
  void set_fallback_type(::FieldType value);
  private:
  ::FieldType _internal_fallback_type() const;
  void _internal_set_fallback_type(::FieldType value);
  public:
 
  // optional bool long_names = 4 [default = true];
  bool has_long_names() const;
  private:
  bool _internal_has_long_names() const;
  public:
  void clear_long_names();
  bool long_names() const;
  void set_long_names(bool value);
  private:
  bool _internal_long_names() const;
  void _internal_set_long_names(bool value);
  public:
 
  // optional bool sort_by_tag = 28 [default = true];
  bool has_sort_by_tag() const;
  private:
  bool _internal_has_sort_by_tag() const;
  public:
  void clear_sort_by_tag();
  bool sort_by_tag() const;
  void set_sort_by_tag(bool value);
  private:
  bool _internal_sort_by_tag() const;
  void _internal_set_sort_by_tag(bool value);
  public:
 
  // optional .google.protobuf.FieldDescriptorProto.Type type_override = 27;
  bool has_type_override() const;
  private:
  bool _internal_has_type_override() const;
  public:
  void clear_type_override();
  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type type_override() const;
  void set_type_override(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
  private:
  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type _internal_type_override() const;
  void _internal_set_type_override(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
  public:
 
  // @@protoc_insertion_point(class_scope:NanoPBOptions)
 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::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> include_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> exclude_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_callback_datatype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callback_datatype_;
    static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_callback_function_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr callback_function_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initializer_;
    int32_t max_size_;
    int32_t max_count_;
    int type_;
    int int_size_;
    bool packed_struct_;
    bool packed_enum_;
    bool skip_message_;
    bool no_unions_;
    uint32_t msgid_;
    int32_t max_length_;
    bool anonymous_oneof_;
    bool proto3_;
    bool proto3_singular_msgs_;
    bool enum_to_string_;
    int mangle_names_;
    bool fixed_length_;
    bool fixed_count_;
    bool submsg_callback_;
    bool default_has_;
    int descriptorsize_;
    int fallback_type_;
    bool long_names_;
    bool sort_by_tag_;
    int type_override_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_nanopb_2eproto;
};
// ===================================================================
 
static const int kNanopbFileoptFieldNumber = 1010;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::FileOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::NanoPBOptions >, 11, false >
  nanopb_fileopt;
static const int kNanopbMsgoptFieldNumber = 1010;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::NanoPBOptions >, 11, false >
  nanopb_msgopt;
static const int kNanopbEnumoptFieldNumber = 1010;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::EnumOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::NanoPBOptions >, 11, false >
  nanopb_enumopt;
static const int kNanopbFieldNumber = 1010;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::FieldOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::NanoPBOptions >, 11, false >
  nanopb;
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// NanoPBOptions
 
// optional int32 max_size = 1;
inline bool NanoPBOptions::_internal_has_max_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NanoPBOptions::has_max_size() const {
  return _internal_has_max_size();
}
inline void NanoPBOptions::clear_max_size() {
  _impl_.max_size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t NanoPBOptions::_internal_max_size() const {
  return _impl_.max_size_;
}
inline int32_t NanoPBOptions::max_size() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.max_size)
  return _internal_max_size();
}
inline void NanoPBOptions::_internal_set_max_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.max_size_ = value;
}
inline void NanoPBOptions::set_max_size(int32_t value) {
  _internal_set_max_size(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.max_size)
}
 
// optional int32 max_length = 14;
inline bool NanoPBOptions::_internal_has_max_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_max_length() const {
  return _internal_has_max_length();
}
inline void NanoPBOptions::clear_max_length() {
  _impl_.max_length_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t NanoPBOptions::_internal_max_length() const {
  return _impl_.max_length_;
}
inline int32_t NanoPBOptions::max_length() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.max_length)
  return _internal_max_length();
}
inline void NanoPBOptions::_internal_set_max_length(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.max_length_ = value;
}
inline void NanoPBOptions::set_max_length(int32_t value) {
  _internal_set_max_length(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.max_length)
}
 
// optional int32 max_count = 2;
inline bool NanoPBOptions::_internal_has_max_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool NanoPBOptions::has_max_count() const {
  return _internal_has_max_count();
}
inline void NanoPBOptions::clear_max_count() {
  _impl_.max_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t NanoPBOptions::_internal_max_count() const {
  return _impl_.max_count_;
}
inline int32_t NanoPBOptions::max_count() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.max_count)
  return _internal_max_count();
}
inline void NanoPBOptions::_internal_set_max_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.max_count_ = value;
}
inline void NanoPBOptions::set_max_count(int32_t value) {
  _internal_set_max_count(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.max_count)
}
 
// optional .IntSize int_size = 7 [default = IS_DEFAULT];
inline bool NanoPBOptions::_internal_has_int_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool NanoPBOptions::has_int_size() const {
  return _internal_has_int_size();
}
inline void NanoPBOptions::clear_int_size() {
  _impl_.int_size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::IntSize NanoPBOptions::_internal_int_size() const {
  return static_cast< ::IntSize >(_impl_.int_size_);
}
inline ::IntSize NanoPBOptions::int_size() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.int_size)
  return _internal_int_size();
}
inline void NanoPBOptions::_internal_set_int_size(::IntSize value) {
  assert(::IntSize_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.int_size_ = value;
}
inline void NanoPBOptions::set_int_size(::IntSize value) {
  _internal_set_int_size(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.int_size)
}
 
// optional .FieldType type = 3 [default = FT_DEFAULT];
inline bool NanoPBOptions::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool NanoPBOptions::has_type() const {
  return _internal_has_type();
}
inline void NanoPBOptions::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::FieldType NanoPBOptions::_internal_type() const {
  return static_cast< ::FieldType >(_impl_.type_);
}
inline ::FieldType NanoPBOptions::type() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.type)
  return _internal_type();
}
inline void NanoPBOptions::_internal_set_type(::FieldType value) {
  assert(::FieldType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.type_ = value;
}
inline void NanoPBOptions::set_type(::FieldType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.type)
}
 
// optional bool long_names = 4 [default = true];
inline bool NanoPBOptions::_internal_has_long_names() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_long_names() const {
  return _internal_has_long_names();
}
inline void NanoPBOptions::clear_long_names() {
  _impl_.long_names_ = true;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline bool NanoPBOptions::_internal_long_names() const {
  return _impl_.long_names_;
}
inline bool NanoPBOptions::long_names() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.long_names)
  return _internal_long_names();
}
inline void NanoPBOptions::_internal_set_long_names(bool value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.long_names_ = value;
}
inline void NanoPBOptions::set_long_names(bool value) {
  _internal_set_long_names(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.long_names)
}
 
// optional bool packed_struct = 5 [default = false];
inline bool NanoPBOptions::_internal_has_packed_struct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool NanoPBOptions::has_packed_struct() const {
  return _internal_has_packed_struct();
}
inline void NanoPBOptions::clear_packed_struct() {
  _impl_.packed_struct_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool NanoPBOptions::_internal_packed_struct() const {
  return _impl_.packed_struct_;
}
inline bool NanoPBOptions::packed_struct() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.packed_struct)
  return _internal_packed_struct();
}
inline void NanoPBOptions::_internal_set_packed_struct(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.packed_struct_ = value;
}
inline void NanoPBOptions::set_packed_struct(bool value) {
  _internal_set_packed_struct(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.packed_struct)
}
 
// optional bool packed_enum = 10 [default = false];
inline bool NanoPBOptions::_internal_has_packed_enum() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool NanoPBOptions::has_packed_enum() const {
  return _internal_has_packed_enum();
}
inline void NanoPBOptions::clear_packed_enum() {
  _impl_.packed_enum_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool NanoPBOptions::_internal_packed_enum() const {
  return _impl_.packed_enum_;
}
inline bool NanoPBOptions::packed_enum() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.packed_enum)
  return _internal_packed_enum();
}
inline void NanoPBOptions::_internal_set_packed_enum(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.packed_enum_ = value;
}
inline void NanoPBOptions::set_packed_enum(bool value) {
  _internal_set_packed_enum(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.packed_enum)
}
 
// optional bool skip_message = 6 [default = false];
inline bool NanoPBOptions::_internal_has_skip_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool NanoPBOptions::has_skip_message() const {
  return _internal_has_skip_message();
}
inline void NanoPBOptions::clear_skip_message() {
  _impl_.skip_message_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool NanoPBOptions::_internal_skip_message() const {
  return _impl_.skip_message_;
}
inline bool NanoPBOptions::skip_message() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.skip_message)
  return _internal_skip_message();
}
inline void NanoPBOptions::_internal_set_skip_message(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.skip_message_ = value;
}
inline void NanoPBOptions::set_skip_message(bool value) {
  _internal_set_skip_message(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.skip_message)
}
 
// optional bool no_unions = 8 [default = false];
inline bool NanoPBOptions::_internal_has_no_unions() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool NanoPBOptions::has_no_unions() const {
  return _internal_has_no_unions();
}
inline void NanoPBOptions::clear_no_unions() {
  _impl_.no_unions_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool NanoPBOptions::_internal_no_unions() const {
  return _impl_.no_unions_;
}
inline bool NanoPBOptions::no_unions() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.no_unions)
  return _internal_no_unions();
}
inline void NanoPBOptions::_internal_set_no_unions(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.no_unions_ = value;
}
inline void NanoPBOptions::set_no_unions(bool value) {
  _internal_set_no_unions(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.no_unions)
}
 
// optional uint32 msgid = 9;
inline bool NanoPBOptions::_internal_has_msgid() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_msgid() const {
  return _internal_has_msgid();
}
inline void NanoPBOptions::clear_msgid() {
  _impl_.msgid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t NanoPBOptions::_internal_msgid() const {
  return _impl_.msgid_;
}
inline uint32_t NanoPBOptions::msgid() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.msgid)
  return _internal_msgid();
}
inline void NanoPBOptions::_internal_set_msgid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.msgid_ = value;
}
inline void NanoPBOptions::set_msgid(uint32_t value) {
  _internal_set_msgid(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.msgid)
}
 
// optional bool anonymous_oneof = 11 [default = false];
inline bool NanoPBOptions::_internal_has_anonymous_oneof() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_anonymous_oneof() const {
  return _internal_has_anonymous_oneof();
}
inline void NanoPBOptions::clear_anonymous_oneof() {
  _impl_.anonymous_oneof_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool NanoPBOptions::_internal_anonymous_oneof() const {
  return _impl_.anonymous_oneof_;
}
inline bool NanoPBOptions::anonymous_oneof() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.anonymous_oneof)
  return _internal_anonymous_oneof();
}
inline void NanoPBOptions::_internal_set_anonymous_oneof(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.anonymous_oneof_ = value;
}
inline void NanoPBOptions::set_anonymous_oneof(bool value) {
  _internal_set_anonymous_oneof(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.anonymous_oneof)
}
 
// optional bool proto3 = 12 [default = false];
inline bool NanoPBOptions::_internal_has_proto3() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_proto3() const {
  return _internal_has_proto3();
}
inline void NanoPBOptions::clear_proto3() {
  _impl_.proto3_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool NanoPBOptions::_internal_proto3() const {
  return _impl_.proto3_;
}
inline bool NanoPBOptions::proto3() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.proto3)
  return _internal_proto3();
}
inline void NanoPBOptions::_internal_set_proto3(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.proto3_ = value;
}
inline void NanoPBOptions::set_proto3(bool value) {
  _internal_set_proto3(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.proto3)
}
 
// optional bool proto3_singular_msgs = 21 [default = false];
inline bool NanoPBOptions::_internal_has_proto3_singular_msgs() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_proto3_singular_msgs() const {
  return _internal_has_proto3_singular_msgs();
}
inline void NanoPBOptions::clear_proto3_singular_msgs() {
  _impl_.proto3_singular_msgs_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool NanoPBOptions::_internal_proto3_singular_msgs() const {
  return _impl_.proto3_singular_msgs_;
}
inline bool NanoPBOptions::proto3_singular_msgs() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.proto3_singular_msgs)
  return _internal_proto3_singular_msgs();
}
inline void NanoPBOptions::_internal_set_proto3_singular_msgs(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.proto3_singular_msgs_ = value;
}
inline void NanoPBOptions::set_proto3_singular_msgs(bool value) {
  _internal_set_proto3_singular_msgs(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.proto3_singular_msgs)
}
 
// optional bool enum_to_string = 13 [default = false];
inline bool NanoPBOptions::_internal_has_enum_to_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_enum_to_string() const {
  return _internal_has_enum_to_string();
}
inline void NanoPBOptions::clear_enum_to_string() {
  _impl_.enum_to_string_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool NanoPBOptions::_internal_enum_to_string() const {
  return _impl_.enum_to_string_;
}
inline bool NanoPBOptions::enum_to_string() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.enum_to_string)
  return _internal_enum_to_string();
}
inline void NanoPBOptions::_internal_set_enum_to_string(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.enum_to_string_ = value;
}
inline void NanoPBOptions::set_enum_to_string(bool value) {
  _internal_set_enum_to_string(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.enum_to_string)
}
 
// optional bool fixed_length = 15 [default = false];
inline bool NanoPBOptions::_internal_has_fixed_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_fixed_length() const {
  return _internal_has_fixed_length();
}
inline void NanoPBOptions::clear_fixed_length() {
  _impl_.fixed_length_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool NanoPBOptions::_internal_fixed_length() const {
  return _impl_.fixed_length_;
}
inline bool NanoPBOptions::fixed_length() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.fixed_length)
  return _internal_fixed_length();
}
inline void NanoPBOptions::_internal_set_fixed_length(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.fixed_length_ = value;
}
inline void NanoPBOptions::set_fixed_length(bool value) {
  _internal_set_fixed_length(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.fixed_length)
}
 
// optional bool fixed_count = 16 [default = false];
inline bool NanoPBOptions::_internal_has_fixed_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_fixed_count() const {
  return _internal_has_fixed_count();
}
inline void NanoPBOptions::clear_fixed_count() {
  _impl_.fixed_count_ = false;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline bool NanoPBOptions::_internal_fixed_count() const {
  return _impl_.fixed_count_;
}
inline bool NanoPBOptions::fixed_count() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.fixed_count)
  return _internal_fixed_count();
}
inline void NanoPBOptions::_internal_set_fixed_count(bool value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.fixed_count_ = value;
}
inline void NanoPBOptions::set_fixed_count(bool value) {
  _internal_set_fixed_count(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.fixed_count)
}
 
// optional bool submsg_callback = 22 [default = false];
inline bool NanoPBOptions::_internal_has_submsg_callback() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_submsg_callback() const {
  return _internal_has_submsg_callback();
}
inline void NanoPBOptions::clear_submsg_callback() {
  _impl_.submsg_callback_ = false;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline bool NanoPBOptions::_internal_submsg_callback() const {
  return _impl_.submsg_callback_;
}
inline bool NanoPBOptions::submsg_callback() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.submsg_callback)
  return _internal_submsg_callback();
}
inline void NanoPBOptions::_internal_set_submsg_callback(bool value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.submsg_callback_ = value;
}
inline void NanoPBOptions::set_submsg_callback(bool value) {
  _internal_set_submsg_callback(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.submsg_callback)
}
 
// optional .TypenameMangling mangle_names = 17 [default = M_NONE];
inline bool NanoPBOptions::_internal_has_mangle_names() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_mangle_names() const {
  return _internal_has_mangle_names();
}
inline void NanoPBOptions::clear_mangle_names() {
  _impl_.mangle_names_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::TypenameMangling NanoPBOptions::_internal_mangle_names() const {
  return static_cast< ::TypenameMangling >(_impl_.mangle_names_);
}
inline ::TypenameMangling NanoPBOptions::mangle_names() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.mangle_names)
  return _internal_mangle_names();
}
inline void NanoPBOptions::_internal_set_mangle_names(::TypenameMangling value) {
  assert(::TypenameMangling_IsValid(value));
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.mangle_names_ = value;
}
inline void NanoPBOptions::set_mangle_names(::TypenameMangling value) {
  _internal_set_mangle_names(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.mangle_names)
}
 
// optional string callback_datatype = 18 [default = "pb_callback_t"];
inline bool NanoPBOptions::_internal_has_callback_datatype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NanoPBOptions::has_callback_datatype() const {
  return _internal_has_callback_datatype();
}
inline void NanoPBOptions::clear_callback_datatype() {
  _impl_.callback_datatype_.ClearToDefault(::NanoPBOptions::Impl_::_i_give_permission_to_break_this_code_default_callback_datatype_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NanoPBOptions::callback_datatype() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.callback_datatype)
  if (_impl_.callback_datatype_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_callback_datatype_.get();
  return _internal_callback_datatype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NanoPBOptions::set_callback_datatype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.callback_datatype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NanoPBOptions.callback_datatype)
}
inline std::string* NanoPBOptions::mutable_callback_datatype() {
  std::string* _s = _internal_mutable_callback_datatype();
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.callback_datatype)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_callback_datatype() const {
  return _impl_.callback_datatype_.Get();
}
inline void NanoPBOptions::_internal_set_callback_datatype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.callback_datatype_.Set(value, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::_internal_mutable_callback_datatype() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.callback_datatype_.Mutable(::NanoPBOptions::Impl_::_i_give_permission_to_break_this_code_default_callback_datatype_, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::release_callback_datatype() {
  // @@protoc_insertion_point(field_release:NanoPBOptions.callback_datatype)
  if (!_internal_has_callback_datatype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.callback_datatype_.Release();
  return p;
}
inline void NanoPBOptions::set_allocated_callback_datatype(std::string* callback_datatype) {
  if (callback_datatype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.callback_datatype_.SetAllocated(callback_datatype, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:NanoPBOptions.callback_datatype)
}
 
// optional string callback_function = 19 [default = "pb_default_field_callback"];
inline bool NanoPBOptions::_internal_has_callback_function() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NanoPBOptions::has_callback_function() const {
  return _internal_has_callback_function();
}
inline void NanoPBOptions::clear_callback_function() {
  _impl_.callback_function_.ClearToDefault(::NanoPBOptions::Impl_::_i_give_permission_to_break_this_code_default_callback_function_, GetArenaForAllocation());
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NanoPBOptions::callback_function() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.callback_function)
  if (_impl_.callback_function_.IsDefault()) return Impl_::_i_give_permission_to_break_this_code_default_callback_function_.get();
  return _internal_callback_function();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NanoPBOptions::set_callback_function(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.callback_function_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NanoPBOptions.callback_function)
}
inline std::string* NanoPBOptions::mutable_callback_function() {
  std::string* _s = _internal_mutable_callback_function();
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.callback_function)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_callback_function() const {
  return _impl_.callback_function_.Get();
}
inline void NanoPBOptions::_internal_set_callback_function(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.callback_function_.Set(value, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::_internal_mutable_callback_function() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.callback_function_.Mutable(::NanoPBOptions::Impl_::_i_give_permission_to_break_this_code_default_callback_function_, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::release_callback_function() {
  // @@protoc_insertion_point(field_release:NanoPBOptions.callback_function)
  if (!_internal_has_callback_function()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.callback_function_.Release();
  return p;
}
inline void NanoPBOptions::set_allocated_callback_function(std::string* callback_function) {
  if (callback_function != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.callback_function_.SetAllocated(callback_function, GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:NanoPBOptions.callback_function)
}
 
// optional .DescriptorSize descriptorsize = 20 [default = DS_AUTO];
inline bool NanoPBOptions::_internal_has_descriptorsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_descriptorsize() const {
  return _internal_has_descriptorsize();
}
inline void NanoPBOptions::clear_descriptorsize() {
  _impl_.descriptorsize_ = 0;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline ::DescriptorSize NanoPBOptions::_internal_descriptorsize() const {
  return static_cast< ::DescriptorSize >(_impl_.descriptorsize_);
}
inline ::DescriptorSize NanoPBOptions::descriptorsize() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.descriptorsize)
  return _internal_descriptorsize();
}
inline void NanoPBOptions::_internal_set_descriptorsize(::DescriptorSize value) {
  assert(::DescriptorSize_IsValid(value));
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.descriptorsize_ = value;
}
inline void NanoPBOptions::set_descriptorsize(::DescriptorSize value) {
  _internal_set_descriptorsize(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.descriptorsize)
}
 
// optional bool default_has = 23 [default = false];
inline bool NanoPBOptions::_internal_has_default_has() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_default_has() const {
  return _internal_has_default_has();
}
inline void NanoPBOptions::clear_default_has() {
  _impl_.default_has_ = false;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool NanoPBOptions::_internal_default_has() const {
  return _impl_.default_has_;
}
inline bool NanoPBOptions::default_has() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.default_has)
  return _internal_default_has();
}
inline void NanoPBOptions::_internal_set_default_has(bool value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.default_has_ = value;
}
inline void NanoPBOptions::set_default_has(bool value) {
  _internal_set_default_has(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.default_has)
}
 
// repeated string include = 24;
inline int NanoPBOptions::_internal_include_size() const {
  return _impl_.include_.size();
}
inline int NanoPBOptions::include_size() const {
  return _internal_include_size();
}
inline void NanoPBOptions::clear_include() {
  _impl_.include_.Clear();
}
inline std::string* NanoPBOptions::add_include() {
  std::string* _s = _internal_add_include();
  // @@protoc_insertion_point(field_add_mutable:NanoPBOptions.include)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_include(int index) const {
  return _impl_.include_.Get(index);
}
inline const std::string& NanoPBOptions::include(int index) const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.include)
  return _internal_include(index);
}
inline std::string* NanoPBOptions::mutable_include(int index) {
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.include)
  return _impl_.include_.Mutable(index);
}
inline void NanoPBOptions::set_include(int index, const std::string& value) {
  _impl_.include_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.include)
}
inline void NanoPBOptions::set_include(int index, std::string&& value) {
  _impl_.include_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:NanoPBOptions.include)
}
inline void NanoPBOptions::set_include(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.include_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:NanoPBOptions.include)
}
inline void NanoPBOptions::set_include(int index, const char* value, size_t size) {
  _impl_.include_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:NanoPBOptions.include)
}
inline std::string* NanoPBOptions::_internal_add_include() {
  return _impl_.include_.Add();
}
inline void NanoPBOptions::add_include(const std::string& value) {
  _impl_.include_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:NanoPBOptions.include)
}
inline void NanoPBOptions::add_include(std::string&& value) {
  _impl_.include_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:NanoPBOptions.include)
}
inline void NanoPBOptions::add_include(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.include_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:NanoPBOptions.include)
}
inline void NanoPBOptions::add_include(const char* value, size_t size) {
  _impl_.include_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:NanoPBOptions.include)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NanoPBOptions::include() const {
  // @@protoc_insertion_point(field_list:NanoPBOptions.include)
  return _impl_.include_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NanoPBOptions::mutable_include() {
  // @@protoc_insertion_point(field_mutable_list:NanoPBOptions.include)
  return &_impl_.include_;
}
 
// repeated string exclude = 26;
inline int NanoPBOptions::_internal_exclude_size() const {
  return _impl_.exclude_.size();
}
inline int NanoPBOptions::exclude_size() const {
  return _internal_exclude_size();
}
inline void NanoPBOptions::clear_exclude() {
  _impl_.exclude_.Clear();
}
inline std::string* NanoPBOptions::add_exclude() {
  std::string* _s = _internal_add_exclude();
  // @@protoc_insertion_point(field_add_mutable:NanoPBOptions.exclude)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_exclude(int index) const {
  return _impl_.exclude_.Get(index);
}
inline const std::string& NanoPBOptions::exclude(int index) const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.exclude)
  return _internal_exclude(index);
}
inline std::string* NanoPBOptions::mutable_exclude(int index) {
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.exclude)
  return _impl_.exclude_.Mutable(index);
}
inline void NanoPBOptions::set_exclude(int index, const std::string& value) {
  _impl_.exclude_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.exclude)
}
inline void NanoPBOptions::set_exclude(int index, std::string&& value) {
  _impl_.exclude_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:NanoPBOptions.exclude)
}
inline void NanoPBOptions::set_exclude(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.exclude_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:NanoPBOptions.exclude)
}
inline void NanoPBOptions::set_exclude(int index, const char* value, size_t size) {
  _impl_.exclude_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:NanoPBOptions.exclude)
}
inline std::string* NanoPBOptions::_internal_add_exclude() {
  return _impl_.exclude_.Add();
}
inline void NanoPBOptions::add_exclude(const std::string& value) {
  _impl_.exclude_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:NanoPBOptions.exclude)
}
inline void NanoPBOptions::add_exclude(std::string&& value) {
  _impl_.exclude_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:NanoPBOptions.exclude)
}
inline void NanoPBOptions::add_exclude(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.exclude_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:NanoPBOptions.exclude)
}
inline void NanoPBOptions::add_exclude(const char* value, size_t size) {
  _impl_.exclude_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:NanoPBOptions.exclude)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NanoPBOptions::exclude() const {
  // @@protoc_insertion_point(field_list:NanoPBOptions.exclude)
  return _impl_.exclude_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NanoPBOptions::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:NanoPBOptions.exclude)
  return &_impl_.exclude_;
}
 
// optional string package = 25;
inline bool NanoPBOptions::_internal_has_package() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NanoPBOptions::has_package() const {
  return _internal_has_package();
}
inline void NanoPBOptions::clear_package() {
  _impl_.package_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& NanoPBOptions::package() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.package)
  return _internal_package();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NanoPBOptions::set_package(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NanoPBOptions.package)
}
inline std::string* NanoPBOptions::mutable_package() {
  std::string* _s = _internal_mutable_package();
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.package)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_package() const {
  return _impl_.package_.Get();
}
inline void NanoPBOptions::_internal_set_package(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.package_.Set(value, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::_internal_mutable_package() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.package_.Mutable(GetArenaForAllocation());
}
inline std::string* NanoPBOptions::release_package() {
  // @@protoc_insertion_point(field_release:NanoPBOptions.package)
  if (!_internal_has_package()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.package_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.package_.IsDefault()) {
    _impl_.package_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NanoPBOptions::set_allocated_package(std::string* package) {
  if (package != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.package_.SetAllocated(package, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.package_.IsDefault()) {
    _impl_.package_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NanoPBOptions.package)
}
 
// optional .google.protobuf.FieldDescriptorProto.Type type_override = 27;
inline bool NanoPBOptions::_internal_has_type_override() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_type_override() const {
  return _internal_has_type_override();
}
inline void NanoPBOptions::clear_type_override() {
  _impl_.type_override_ = 1;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type NanoPBOptions::_internal_type_override() const {
  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type >(_impl_.type_override_);
}
inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type NanoPBOptions::type_override() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.type_override)
  return _internal_type_override();
}
inline void NanoPBOptions::_internal_set_type_override(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
  assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.type_override_ = value;
}
inline void NanoPBOptions::set_type_override(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
  _internal_set_type_override(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.type_override)
}
 
// optional bool sort_by_tag = 28 [default = true];
inline bool NanoPBOptions::_internal_has_sort_by_tag() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_sort_by_tag() const {
  return _internal_has_sort_by_tag();
}
inline void NanoPBOptions::clear_sort_by_tag() {
  _impl_.sort_by_tag_ = true;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline bool NanoPBOptions::_internal_sort_by_tag() const {
  return _impl_.sort_by_tag_;
}
inline bool NanoPBOptions::sort_by_tag() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.sort_by_tag)
  return _internal_sort_by_tag();
}
inline void NanoPBOptions::_internal_set_sort_by_tag(bool value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.sort_by_tag_ = value;
}
inline void NanoPBOptions::set_sort_by_tag(bool value) {
  _internal_set_sort_by_tag(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.sort_by_tag)
}
 
// optional .FieldType fallback_type = 29 [default = FT_CALLBACK];
inline bool NanoPBOptions::_internal_has_fallback_type() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool NanoPBOptions::has_fallback_type() const {
  return _internal_has_fallback_type();
}
inline void NanoPBOptions::clear_fallback_type() {
  _impl_.fallback_type_ = 1;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline ::FieldType NanoPBOptions::_internal_fallback_type() const {
  return static_cast< ::FieldType >(_impl_.fallback_type_);
}
inline ::FieldType NanoPBOptions::fallback_type() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.fallback_type)
  return _internal_fallback_type();
}
inline void NanoPBOptions::_internal_set_fallback_type(::FieldType value) {
  assert(::FieldType_IsValid(value));
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.fallback_type_ = value;
}
inline void NanoPBOptions::set_fallback_type(::FieldType value) {
  _internal_set_fallback_type(value);
  // @@protoc_insertion_point(field_set:NanoPBOptions.fallback_type)
}
 
// optional string initializer = 30;
inline bool NanoPBOptions::_internal_has_initializer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NanoPBOptions::has_initializer() const {
  return _internal_has_initializer();
}
inline void NanoPBOptions::clear_initializer() {
  _impl_.initializer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& NanoPBOptions::initializer() const {
  // @@protoc_insertion_point(field_get:NanoPBOptions.initializer)
  return _internal_initializer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NanoPBOptions::set_initializer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.initializer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:NanoPBOptions.initializer)
}
inline std::string* NanoPBOptions::mutable_initializer() {
  std::string* _s = _internal_mutable_initializer();
  // @@protoc_insertion_point(field_mutable:NanoPBOptions.initializer)
  return _s;
}
inline const std::string& NanoPBOptions::_internal_initializer() const {
  return _impl_.initializer_.Get();
}
inline void NanoPBOptions::_internal_set_initializer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.initializer_.Set(value, GetArenaForAllocation());
}
inline std::string* NanoPBOptions::_internal_mutable_initializer() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.initializer_.Mutable(GetArenaForAllocation());
}
inline std::string* NanoPBOptions::release_initializer() {
  // @@protoc_insertion_point(field_release:NanoPBOptions.initializer)
  if (!_internal_has_initializer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.initializer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.initializer_.IsDefault()) {
    _impl_.initializer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NanoPBOptions::set_allocated_initializer(std::string* initializer) {
  if (initializer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.initializer_.SetAllocated(initializer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.initializer_.IsDefault()) {
    _impl_.initializer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:NanoPBOptions.initializer)
}
 
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
 
// @@protoc_insertion_point(namespace_scope)
 
 
PROTOBUF_NAMESPACE_OPEN
 
template <> struct is_proto_enum< ::FieldType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::FieldType>() {
  return ::FieldType_descriptor();
}
template <> struct is_proto_enum< ::IntSize> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::IntSize>() {
  return ::IntSize_descriptor();
}
template <> struct is_proto_enum< ::TypenameMangling> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::TypenameMangling>() {
  return ::TypenameMangling_descriptor();
}
template <> struct is_proto_enum< ::DescriptorSize> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::DescriptorSize>() {
  return ::DescriptorSize_descriptor();
}
 
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
 
#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_nanopb_2eproto