include/onnx/onnx-data.pb.h

0001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
0002 // NO CHECKED-IN PROTOBUF GENCODE
0003 // source: onnx/onnx-data.proto
0004 // Protobuf C++ Version: 5.28.2
0005
0006 #ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_2eproto_2epb_2eh
0007 #define GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_2eproto_2epb_2eh
0008
0009 #include <limits>
0010 #include <string>
0011 #include <type_traits>
0012 #include <utility>
0013
0014 #include "google/protobuf/runtime_version.h"
0015 #if PROTOBUF_VERSION != 5028002
0016 #error "Protobuf C++ gencode is built with an incompatible version of"
0017 #error "Protobuf C++ headers/runtime. See"
0018 #error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
0019 #endif
0020 #include "google/protobuf/io/coded_stream.h"
0021 #include "google/protobuf/arena.h"
0022 #include "google/protobuf/arenastring.h"
0023 #include "google/protobuf/generated_message_tctable_decl.h"
0024 #include "google/protobuf/generated_message_util.h"
0025 #include "google/protobuf/metadata_lite.h"
0026 #include "google/protobuf/generated_message_reflection.h"
0027 #include "google/protobuf/message.h"
0028 #include "google/protobuf/repeated_field.h"  // IWYU pragma: export
0029 #include "google/protobuf/extension_set.h"  // IWYU pragma: export
0030 #include "google/protobuf/generated_enum_reflection.h"
0031 #include "google/protobuf/unknown_field_set.h"
0032 #include "onnx/onnx-ml.pb.h"
0033 // @@protoc_insertion_point(includes)
0034
0035 // Must be included last.
0036 #include "google/protobuf/port_def.inc"
0037
0038 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2ddata_2eproto ONNX_API
0039
0040 namespace google {
0041 namespace protobuf {
0042 namespace internal {
0043 class AnyMetadata;
0044 }  // namespace internal
0045 }  // namespace protobuf
0046 }  // namespace google
0047
0048 // Internal implementation detail -- do not use these members.
0049 struct ONNX_API TableStruct_onnx_2fonnx_2ddata_2eproto {
0050   static const ::uint32_t offsets[];
0051 };
0052 ONNX_API extern const ::google::protobuf::internal::DescriptorTable
0053     descriptor_table_onnx_2fonnx_2ddata_2eproto;
0054 namespace onnx {
0055 class MapProto;
0056 struct MapProtoDefaultTypeInternal;
0057 ONNX_API extern MapProtoDefaultTypeInternal _MapProto_default_instance_;
0058 class OptionalProto;
0059 struct OptionalProtoDefaultTypeInternal;
0060 ONNX_API extern OptionalProtoDefaultTypeInternal _OptionalProto_default_instance_;
0061 class SequenceProto;
0062 struct SequenceProtoDefaultTypeInternal;
0063 ONNX_API extern SequenceProtoDefaultTypeInternal _SequenceProto_default_instance_;
0064 }  // namespace onnx
0065 namespace google {
0066 namespace protobuf {
0067 }  // namespace protobuf
0068 }  // namespace google
0069
0070 namespace onnx {
0071 enum SequenceProto_DataType : int {
0072   SequenceProto_DataType_UNDEFINED = 0,
0073   SequenceProto_DataType_TENSOR = 1,
0074   SequenceProto_DataType_SPARSE_TENSOR = 2,
0075   SequenceProto_DataType_SEQUENCE = 3,
0076   SequenceProto_DataType_MAP = 4,
0077   SequenceProto_DataType_OPTIONAL = 5,
0078 };
0079
0080 ONNX_API bool SequenceProto_DataType_IsValid(int value);
0081 ONNX_API extern const uint32_t SequenceProto_DataType_internal_data_[];
0082 constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MIN = static_cast<SequenceProto_DataType>(0);
0083 constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MAX = static_cast<SequenceProto_DataType>(5);
0084 constexpr int SequenceProto_DataType_DataType_ARRAYSIZE = 5 + 1;
0085 ONNX_API const ::google::protobuf::EnumDescriptor*
0086 SequenceProto_DataType_descriptor();
0087 template <typename T>
0088 const std::string& SequenceProto_DataType_Name(T value) {
0089   static_assert(std::is_same<T, SequenceProto_DataType>::value ||
0090                     std::is_integral<T>::value,
0091                 "Incorrect type passed to DataType_Name().");
0092   return SequenceProto_DataType_Name(static_cast<SequenceProto_DataType>(value));
0093 }
0094 template <>
0095 inline const std::string& SequenceProto_DataType_Name(SequenceProto_DataType value) {
0096   return ::google::protobuf::internal::NameOfDenseEnum<SequenceProto_DataType_descriptor,
0097                                                  0, 5>(
0098       static_cast<int>(value));
0099 }
0100 inline bool SequenceProto_DataType_Parse(absl::string_view name, SequenceProto_DataType* value) {
0101   return ::google::protobuf::internal::ParseNamedEnum<SequenceProto_DataType>(
0102       SequenceProto_DataType_descriptor(), name, value);
0103 }
0104 enum OptionalProto_DataType : int {
0105   OptionalProto_DataType_UNDEFINED = 0,
0106   OptionalProto_DataType_TENSOR = 1,
0107   OptionalProto_DataType_SPARSE_TENSOR = 2,
0108   OptionalProto_DataType_SEQUENCE = 3,
0109   OptionalProto_DataType_MAP = 4,
0110   OptionalProto_DataType_OPTIONAL = 5,
0111 };
0112
0113 ONNX_API bool OptionalProto_DataType_IsValid(int value);
0114 ONNX_API extern const uint32_t OptionalProto_DataType_internal_data_[];
0115 constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MIN = static_cast<OptionalProto_DataType>(0);
0116 constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MAX = static_cast<OptionalProto_DataType>(5);
0117 constexpr int OptionalProto_DataType_DataType_ARRAYSIZE = 5 + 1;
0118 ONNX_API const ::google::protobuf::EnumDescriptor*
0119 OptionalProto_DataType_descriptor();
0120 template <typename T>
0121 const std::string& OptionalProto_DataType_Name(T value) {
0122   static_assert(std::is_same<T, OptionalProto_DataType>::value ||
0123                     std::is_integral<T>::value,
0124                 "Incorrect type passed to DataType_Name().");
0125   return OptionalProto_DataType_Name(static_cast<OptionalProto_DataType>(value));
0126 }
0127 template <>
0128 inline const std::string& OptionalProto_DataType_Name(OptionalProto_DataType value) {
0129   return ::google::protobuf::internal::NameOfDenseEnum<OptionalProto_DataType_descriptor,
0130                                                  0, 5>(
0131       static_cast<int>(value));
0132 }
0133 inline bool OptionalProto_DataType_Parse(absl::string_view name, OptionalProto_DataType* value) {
0134   return ::google::protobuf::internal::ParseNamedEnum<OptionalProto_DataType>(
0135       OptionalProto_DataType_descriptor(), name, value);
0136 }
0137
0138 // ===================================================================
0139
0140
0141 // -------------------------------------------------------------------
0142
0143 class ONNX_API MapProto final : public ::google::protobuf::Message
0144 /* @@protoc_insertion_point(class_definition:onnx.MapProto) */ {
0145  public:
0146   inline MapProto() : MapProto(nullptr) {}
0147   ~MapProto() PROTOBUF_FINAL;
0148   template <typename = void>
0149   explicit PROTOBUF_CONSTEXPR MapProto(
0150       ::google::protobuf::internal::ConstantInitialized);
0151
0152   inline MapProto(const MapProto& from) : MapProto(nullptr, from) {}
0153   inline MapProto(MapProto&& from) noexcept
0154       : MapProto(nullptr, std::move(from)) {}
0155   inline MapProto& operator=(const MapProto& from) {
0156     CopyFrom(from);
0157     return *this;
0158   }
0159   inline MapProto& operator=(MapProto&& from) noexcept {
0160     if (this == &from) return *this;
0161     if (GetArena() == from.GetArena()
0162 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0163         && GetArena() != nullptr
0164 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0165     ) {
0166       InternalSwap(&from);
0167     } else {
0168       CopyFrom(from);
0169     }
0170     return *this;
0171   }
0172
0173   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0174       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0175     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0176   }
0177   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0178       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0179     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0180   }
0181
0182   static const ::google::protobuf::Descriptor* descriptor() {
0183     return GetDescriptor();
0184   }
0185   static const ::google::protobuf::Descriptor* GetDescriptor() {
0186     return default_instance().GetMetadata().descriptor;
0187   }
0188   static const ::google::protobuf::Reflection* GetReflection() {
0189     return default_instance().GetMetadata().reflection;
0190   }
0191   static const MapProto& default_instance() {
0192     return *internal_default_instance();
0193   }
0194   static inline const MapProto* internal_default_instance() {
0195     return reinterpret_cast<const MapProto*>(
0196         &_MapProto_default_instance_);
0197   }
0198   static constexpr int kIndexInFileMessages = 1;
0199   friend void swap(MapProto& a, MapProto& b) { a.Swap(&b); }
0200   inline void Swap(MapProto* other) {
0201     if (other == this) return;
0202 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0203     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0204 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0205     if (GetArena() == other->GetArena()) {
0206 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0207       InternalSwap(other);
0208     } else {
0209       ::google::protobuf::internal::GenericSwap(this, other);
0210     }
0211   }
0212   void UnsafeArenaSwap(MapProto* other) {
0213     if (other == this) return;
0214     ABSL_DCHECK(GetArena() == other->GetArena());
0215     InternalSwap(other);
0216   }
0217
0218   // implements Message ----------------------------------------------
0219
0220   MapProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0221     return ::google::protobuf::Message::DefaultConstruct<MapProto>(arena);
0222   }
0223   using ::google::protobuf::Message::CopyFrom;
0224   void CopyFrom(const MapProto& from);
0225   using ::google::protobuf::Message::MergeFrom;
0226   void MergeFrom(const MapProto& from) { MapProto::MergeImpl(*this, from); }
0227
0228   private:
0229   static void MergeImpl(
0230       ::google::protobuf::MessageLite& to_msg,
0231       const ::google::protobuf::MessageLite& from_msg);
0232
0233   public:
0234   bool IsInitialized() const {
0235     return true;
0236   }
0237   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0238   #if defined(PROTOBUF_CUSTOM_VTABLE)
0239   private:
0240   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0241   static ::uint8_t* _InternalSerialize(
0242       const MessageLite& msg, ::uint8_t* target,
0243       ::google::protobuf::io::EpsCopyOutputStream* stream);
0244
0245   public:
0246   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0247   ::uint8_t* _InternalSerialize(
0248       ::uint8_t* target,
0249       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0250     return _InternalSerialize(*this, target, stream);
0251   }
0252   #else   // PROTOBUF_CUSTOM_VTABLE
0253   ::size_t ByteSizeLong() const final;
0254   ::uint8_t* _InternalSerialize(
0255       ::uint8_t* target,
0256       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0257   #endif  // PROTOBUF_CUSTOM_VTABLE
0258   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0259
0260   private:
0261   void SharedCtor(::google::protobuf::Arena* arena);
0262   void SharedDtor();
0263   void InternalSwap(MapProto* other);
0264  private:
0265   friend class ::google::protobuf::internal::AnyMetadata;
0266   static ::absl::string_view FullMessageName() { return "onnx.MapProto"; }
0267
0268  protected:
0269   explicit MapProto(::google::protobuf::Arena* arena);
0270   MapProto(::google::protobuf::Arena* arena, const MapProto& from);
0271   MapProto(::google::protobuf::Arena* arena, MapProto&& from) noexcept
0272       : MapProto(arena) {
0273     *this = ::std::move(from);
0274   }
0275   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0276   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0277
0278  public:
0279   ::google::protobuf::Metadata GetMetadata() const;
0280   // nested types ----------------------------------------------------
0281
0282   // accessors -------------------------------------------------------
0283   enum : int {
0284     kKeysFieldNumber = 3,
0285     kStringKeysFieldNumber = 4,
0286     kNameFieldNumber = 1,
0287     kValuesFieldNumber = 5,
0288     kKeyTypeFieldNumber = 2,
0289   };
0290   // repeated int64 keys = 3;
0291   int keys_size() const;
0292   private:
0293   int _internal_keys_size() const;
0294
0295   public:
0296   void clear_keys() ;
0297   ::int64_t keys(int index) const;
0298   void set_keys(int index, ::int64_t value);
0299   void add_keys(::int64_t value);
0300   const ::google::protobuf::RepeatedField<::int64_t>& keys() const;
0301   ::google::protobuf::RepeatedField<::int64_t>* mutable_keys();
0302
0303   private:
0304   const ::google::protobuf::RepeatedField<::int64_t>& _internal_keys() const;
0305   ::google::protobuf::RepeatedField<::int64_t>* _internal_mutable_keys();
0306
0307   public:
0308   // repeated bytes string_keys = 4;
0309   int string_keys_size() const;
0310   private:
0311   int _internal_string_keys_size() const;
0312
0313   public:
0314   void clear_string_keys() ;
0315   const std::string& string_keys(int index) const;
0316   std::string* mutable_string_keys(int index);
0317   template <typename Arg_ = const std::string&, typename... Args_>
0318   void set_string_keys(int index, Arg_&& value, Args_... args);
0319   std::string* add_string_keys();
0320   template <typename Arg_ = const std::string&, typename... Args_>
0321   void add_string_keys(Arg_&& value, Args_... args);
0322   const ::google::protobuf::RepeatedPtrField<std::string>& string_keys() const;
0323   ::google::protobuf::RepeatedPtrField<std::string>* mutable_string_keys();
0324
0325   private:
0326   const ::google::protobuf::RepeatedPtrField<std::string>& _internal_string_keys() const;
0327   ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_string_keys();
0328
0329   public:
0330   // optional string name = 1;
0331   bool has_name() const;
0332   void clear_name() ;
0333   const std::string& name() const;
0334   template <typename Arg_ = const std::string&, typename... Args_>
0335   void set_name(Arg_&& arg, Args_... args);
0336   std::string* mutable_name();
0337   PROTOBUF_NODISCARD std::string* release_name();
0338   void set_allocated_name(std::string* value);
0339
0340   private:
0341   const std::string& _internal_name() const;
0342   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
0343       const std::string& value);
0344   std::string* _internal_mutable_name();
0345
0346   public:
0347   // optional .onnx.SequenceProto values = 5;
0348   bool has_values() const;
0349   void clear_values() ;
0350   const ::onnx::SequenceProto& values() const;
0351   PROTOBUF_NODISCARD ::onnx::SequenceProto* release_values();
0352   ::onnx::SequenceProto* mutable_values();
0353   void set_allocated_values(::onnx::SequenceProto* value);
0354   void unsafe_arena_set_allocated_values(::onnx::SequenceProto* value);
0355   ::onnx::SequenceProto* unsafe_arena_release_values();
0356
0357   private:
0358   const ::onnx::SequenceProto& _internal_values() const;
0359   ::onnx::SequenceProto* _internal_mutable_values();
0360
0361   public:
0362   // optional int32 key_type = 2;
0363   bool has_key_type() const;
0364   void clear_key_type() ;
0365   ::int32_t key_type() const;
0366   void set_key_type(::int32_t value);
0367
0368   private:
0369   ::int32_t _internal_key_type() const;
0370   void _internal_set_key_type(::int32_t value);
0371
0372   public:
0373   // @@protoc_insertion_point(class_scope:onnx.MapProto)
0374  private:
0375   class _Internal;
0376   friend class ::google::protobuf::internal::TcParser;
0377   static const ::google::protobuf::internal::TcParseTable<
0378       3, 5, 1,
0379       26, 2>
0380       _table_;
0381
0382
0383   friend class ::google::protobuf::MessageLite;
0384   friend class ::google::protobuf::Arena;
0385   template <typename T>
0386   friend class ::google::protobuf::Arena::InternalHelper;
0387   using InternalArenaConstructable_ = void;
0388   using DestructorSkippable_ = void;
0389   struct Impl_ {
0390     inline explicit constexpr Impl_(
0391         ::google::protobuf::internal::ConstantInitialized) noexcept;
0392     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0393                           ::google::protobuf::Arena* arena);
0394     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0395                           ::google::protobuf::Arena* arena, const Impl_& from,
0396                           const MapProto& from_msg);
0397     ::google::protobuf::internal::HasBits<1> _has_bits_;
0398     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0399     ::google::protobuf::RepeatedField<::int64_t> keys_;
0400     ::google::protobuf::RepeatedPtrField<std::string> string_keys_;
0401     ::google::protobuf::internal::ArenaStringPtr name_;
0402     ::onnx::SequenceProto* values_;
0403     ::int32_t key_type_;
0404     PROTOBUF_TSAN_DECLARE_MEMBER
0405   };
0406   union { Impl_ _impl_; };
0407   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
0408 };
0409 // -------------------------------------------------------------------
0410
0411 class ONNX_API OptionalProto final : public ::google::protobuf::Message
0412 /* @@protoc_insertion_point(class_definition:onnx.OptionalProto) */ {
0413  public:
0414   inline OptionalProto() : OptionalProto(nullptr) {}
0415   ~OptionalProto() PROTOBUF_FINAL;
0416   template <typename = void>
0417   explicit PROTOBUF_CONSTEXPR OptionalProto(
0418       ::google::protobuf::internal::ConstantInitialized);
0419
0420   inline OptionalProto(const OptionalProto& from) : OptionalProto(nullptr, from) {}
0421   inline OptionalProto(OptionalProto&& from) noexcept
0422       : OptionalProto(nullptr, std::move(from)) {}
0423   inline OptionalProto& operator=(const OptionalProto& from) {
0424     CopyFrom(from);
0425     return *this;
0426   }
0427   inline OptionalProto& operator=(OptionalProto&& from) noexcept {
0428     if (this == &from) return *this;
0429     if (GetArena() == from.GetArena()
0430 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0431         && GetArena() != nullptr
0432 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0433     ) {
0434       InternalSwap(&from);
0435     } else {
0436       CopyFrom(from);
0437     }
0438     return *this;
0439   }
0440
0441   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0442       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0443     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0444   }
0445   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0446       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0447     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0448   }
0449
0450   static const ::google::protobuf::Descriptor* descriptor() {
0451     return GetDescriptor();
0452   }
0453   static const ::google::protobuf::Descriptor* GetDescriptor() {
0454     return default_instance().GetMetadata().descriptor;
0455   }
0456   static const ::google::protobuf::Reflection* GetReflection() {
0457     return default_instance().GetMetadata().reflection;
0458   }
0459   static const OptionalProto& default_instance() {
0460     return *internal_default_instance();
0461   }
0462   static inline const OptionalProto* internal_default_instance() {
0463     return reinterpret_cast<const OptionalProto*>(
0464         &_OptionalProto_default_instance_);
0465   }
0466   static constexpr int kIndexInFileMessages = 2;
0467   friend void swap(OptionalProto& a, OptionalProto& b) { a.Swap(&b); }
0468   inline void Swap(OptionalProto* other) {
0469     if (other == this) return;
0470 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0471     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0472 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0473     if (GetArena() == other->GetArena()) {
0474 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0475       InternalSwap(other);
0476     } else {
0477       ::google::protobuf::internal::GenericSwap(this, other);
0478     }
0479   }
0480   void UnsafeArenaSwap(OptionalProto* other) {
0481     if (other == this) return;
0482     ABSL_DCHECK(GetArena() == other->GetArena());
0483     InternalSwap(other);
0484   }
0485
0486   // implements Message ----------------------------------------------
0487
0488   OptionalProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0489     return ::google::protobuf::Message::DefaultConstruct<OptionalProto>(arena);
0490   }
0491   using ::google::protobuf::Message::CopyFrom;
0492   void CopyFrom(const OptionalProto& from);
0493   using ::google::protobuf::Message::MergeFrom;
0494   void MergeFrom(const OptionalProto& from) { OptionalProto::MergeImpl(*this, from); }
0495
0496   private:
0497   static void MergeImpl(
0498       ::google::protobuf::MessageLite& to_msg,
0499       const ::google::protobuf::MessageLite& from_msg);
0500
0501   public:
0502   bool IsInitialized() const {
0503     return true;
0504   }
0505   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0506   #if defined(PROTOBUF_CUSTOM_VTABLE)
0507   private:
0508   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0509   static ::uint8_t* _InternalSerialize(
0510       const MessageLite& msg, ::uint8_t* target,
0511       ::google::protobuf::io::EpsCopyOutputStream* stream);
0512
0513   public:
0514   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0515   ::uint8_t* _InternalSerialize(
0516       ::uint8_t* target,
0517       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0518     return _InternalSerialize(*this, target, stream);
0519   }
0520   #else   // PROTOBUF_CUSTOM_VTABLE
0521   ::size_t ByteSizeLong() const final;
0522   ::uint8_t* _InternalSerialize(
0523       ::uint8_t* target,
0524       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0525   #endif  // PROTOBUF_CUSTOM_VTABLE
0526   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0527
0528   private:
0529   void SharedCtor(::google::protobuf::Arena* arena);
0530   void SharedDtor();
0531   void InternalSwap(OptionalProto* other);
0532  private:
0533   friend class ::google::protobuf::internal::AnyMetadata;
0534   static ::absl::string_view FullMessageName() { return "onnx.OptionalProto"; }
0535
0536  protected:
0537   explicit OptionalProto(::google::protobuf::Arena* arena);
0538   OptionalProto(::google::protobuf::Arena* arena, const OptionalProto& from);
0539   OptionalProto(::google::protobuf::Arena* arena, OptionalProto&& from) noexcept
0540       : OptionalProto(arena) {
0541     *this = ::std::move(from);
0542   }
0543   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0544   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0545
0546  public:
0547   ::google::protobuf::Metadata GetMetadata() const;
0548   // nested types ----------------------------------------------------
0549   using DataType = OptionalProto_DataType;
0550   static constexpr DataType UNDEFINED = OptionalProto_DataType_UNDEFINED;
0551   static constexpr DataType TENSOR = OptionalProto_DataType_TENSOR;
0552   static constexpr DataType SPARSE_TENSOR = OptionalProto_DataType_SPARSE_TENSOR;
0553   static constexpr DataType SEQUENCE = OptionalProto_DataType_SEQUENCE;
0554   static constexpr DataType MAP = OptionalProto_DataType_MAP;
0555   static constexpr DataType OPTIONAL = OptionalProto_DataType_OPTIONAL;
0556   static inline bool DataType_IsValid(int value) {
0557     return OptionalProto_DataType_IsValid(value);
0558   }
0559   static constexpr DataType DataType_MIN = OptionalProto_DataType_DataType_MIN;
0560   static constexpr DataType DataType_MAX = OptionalProto_DataType_DataType_MAX;
0561   static constexpr int DataType_ARRAYSIZE = OptionalProto_DataType_DataType_ARRAYSIZE;
0562   static inline const ::google::protobuf::EnumDescriptor* DataType_descriptor() {
0563     return OptionalProto_DataType_descriptor();
0564   }
0565   template <typename T>
0566   static inline const std::string& DataType_Name(T value) {
0567     return OptionalProto_DataType_Name(value);
0568   }
0569   static inline bool DataType_Parse(absl::string_view name, DataType* value) {
0570     return OptionalProto_DataType_Parse(name, value);
0571   }
0572
0573   // accessors -------------------------------------------------------
0574   enum : int {
0575     kNameFieldNumber = 1,
0576     kTensorValueFieldNumber = 3,
0577     kSparseTensorValueFieldNumber = 4,
0578     kSequenceValueFieldNumber = 5,
0579     kMapValueFieldNumber = 6,
0580     kOptionalValueFieldNumber = 7,
0581     kElemTypeFieldNumber = 2,
0582   };
0583   // optional string name = 1;
0584   bool has_name() const;
0585   void clear_name() ;
0586   const std::string& name() const;
0587   template <typename Arg_ = const std::string&, typename... Args_>
0588   void set_name(Arg_&& arg, Args_... args);
0589   std::string* mutable_name();
0590   PROTOBUF_NODISCARD std::string* release_name();
0591   void set_allocated_name(std::string* value);
0592
0593   private:
0594   const std::string& _internal_name() const;
0595   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
0596       const std::string& value);
0597   std::string* _internal_mutable_name();
0598
0599   public:
0600   // optional .onnx.TensorProto tensor_value = 3;
0601   bool has_tensor_value() const;
0602   void clear_tensor_value() ;
0603   const ::onnx::TensorProto& tensor_value() const;
0604   PROTOBUF_NODISCARD ::onnx::TensorProto* release_tensor_value();
0605   ::onnx::TensorProto* mutable_tensor_value();
0606   void set_allocated_tensor_value(::onnx::TensorProto* value);
0607   void unsafe_arena_set_allocated_tensor_value(::onnx::TensorProto* value);
0608   ::onnx::TensorProto* unsafe_arena_release_tensor_value();
0609
0610   private:
0611   const ::onnx::TensorProto& _internal_tensor_value() const;
0612   ::onnx::TensorProto* _internal_mutable_tensor_value();
0613
0614   public:
0615   // optional .onnx.SparseTensorProto sparse_tensor_value = 4;
0616   bool has_sparse_tensor_value() const;
0617   void clear_sparse_tensor_value() ;
0618   const ::onnx::SparseTensorProto& sparse_tensor_value() const;
0619   PROTOBUF_NODISCARD ::onnx::SparseTensorProto* release_sparse_tensor_value();
0620   ::onnx::SparseTensorProto* mutable_sparse_tensor_value();
0621   void set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* value);
0622   void unsafe_arena_set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* value);
0623   ::onnx::SparseTensorProto* unsafe_arena_release_sparse_tensor_value();
0624
0625   private:
0626   const ::onnx::SparseTensorProto& _internal_sparse_tensor_value() const;
0627   ::onnx::SparseTensorProto* _internal_mutable_sparse_tensor_value();
0628
0629   public:
0630   // optional .onnx.SequenceProto sequence_value = 5;
0631   bool has_sequence_value() const;
0632   void clear_sequence_value() ;
0633   const ::onnx::SequenceProto& sequence_value() const;
0634   PROTOBUF_NODISCARD ::onnx::SequenceProto* release_sequence_value();
0635   ::onnx::SequenceProto* mutable_sequence_value();
0636   void set_allocated_sequence_value(::onnx::SequenceProto* value);
0637   void unsafe_arena_set_allocated_sequence_value(::onnx::SequenceProto* value);
0638   ::onnx::SequenceProto* unsafe_arena_release_sequence_value();
0639
0640   private:
0641   const ::onnx::SequenceProto& _internal_sequence_value() const;
0642   ::onnx::SequenceProto* _internal_mutable_sequence_value();
0643
0644   public:
0645   // optional .onnx.MapProto map_value = 6;
0646   bool has_map_value() const;
0647   void clear_map_value() ;
0648   const ::onnx::MapProto& map_value() const;
0649   PROTOBUF_NODISCARD ::onnx::MapProto* release_map_value();
0650   ::onnx::MapProto* mutable_map_value();
0651   void set_allocated_map_value(::onnx::MapProto* value);
0652   void unsafe_arena_set_allocated_map_value(::onnx::MapProto* value);
0653   ::onnx::MapProto* unsafe_arena_release_map_value();
0654
0655   private:
0656   const ::onnx::MapProto& _internal_map_value() const;
0657   ::onnx::MapProto* _internal_mutable_map_value();
0658
0659   public:
0660   // optional .onnx.OptionalProto optional_value = 7;
0661   bool has_optional_value() const;
0662   void clear_optional_value() ;
0663   const ::onnx::OptionalProto& optional_value() const;
0664   PROTOBUF_NODISCARD ::onnx::OptionalProto* release_optional_value();
0665   ::onnx::OptionalProto* mutable_optional_value();
0666   void set_allocated_optional_value(::onnx::OptionalProto* value);
0667   void unsafe_arena_set_allocated_optional_value(::onnx::OptionalProto* value);
0668   ::onnx::OptionalProto* unsafe_arena_release_optional_value();
0669
0670   private:
0671   const ::onnx::OptionalProto& _internal_optional_value() const;
0672   ::onnx::OptionalProto* _internal_mutable_optional_value();
0673
0674   public:
0675   // optional int32 elem_type = 2;
0676   bool has_elem_type() const;
0677   void clear_elem_type() ;
0678   ::int32_t elem_type() const;
0679   void set_elem_type(::int32_t value);
0680
0681   private:
0682   ::int32_t _internal_elem_type() const;
0683   void _internal_set_elem_type(::int32_t value);
0684
0685   public:
0686   // @@protoc_insertion_point(class_scope:onnx.OptionalProto)
0687  private:
0688   class _Internal;
0689   friend class ::google::protobuf::internal::TcParser;
0690   static const ::google::protobuf::internal::TcParseTable<
0691       3, 7, 5,
0692       31, 2>
0693       _table_;
0694
0695
0696   friend class ::google::protobuf::MessageLite;
0697   friend class ::google::protobuf::Arena;
0698   template <typename T>
0699   friend class ::google::protobuf::Arena::InternalHelper;
0700   using InternalArenaConstructable_ = void;
0701   using DestructorSkippable_ = void;
0702   struct Impl_ {
0703     inline explicit constexpr Impl_(
0704         ::google::protobuf::internal::ConstantInitialized) noexcept;
0705     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0706                           ::google::protobuf::Arena* arena);
0707     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0708                           ::google::protobuf::Arena* arena, const Impl_& from,
0709                           const OptionalProto& from_msg);
0710     ::google::protobuf::internal::HasBits<1> _has_bits_;
0711     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0712     ::google::protobuf::internal::ArenaStringPtr name_;
0713     ::onnx::TensorProto* tensor_value_;
0714     ::onnx::SparseTensorProto* sparse_tensor_value_;
0715     ::onnx::SequenceProto* sequence_value_;
0716     ::onnx::MapProto* map_value_;
0717     ::onnx::OptionalProto* optional_value_;
0718     ::int32_t elem_type_;
0719     PROTOBUF_TSAN_DECLARE_MEMBER
0720   };
0721   union { Impl_ _impl_; };
0722   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
0723 };
0724 // -------------------------------------------------------------------
0725
0726 class ONNX_API SequenceProto final : public ::google::protobuf::Message
0727 /* @@protoc_insertion_point(class_definition:onnx.SequenceProto) */ {
0728  public:
0729   inline SequenceProto() : SequenceProto(nullptr) {}
0730   ~SequenceProto() PROTOBUF_FINAL;
0731   template <typename = void>
0732   explicit PROTOBUF_CONSTEXPR SequenceProto(
0733       ::google::protobuf::internal::ConstantInitialized);
0734
0735   inline SequenceProto(const SequenceProto& from) : SequenceProto(nullptr, from) {}
0736   inline SequenceProto(SequenceProto&& from) noexcept
0737       : SequenceProto(nullptr, std::move(from)) {}
0738   inline SequenceProto& operator=(const SequenceProto& from) {
0739     CopyFrom(from);
0740     return *this;
0741   }
0742   inline SequenceProto& operator=(SequenceProto&& from) noexcept {
0743     if (this == &from) return *this;
0744     if (GetArena() == from.GetArena()
0745 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0746         && GetArena() != nullptr
0747 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0748     ) {
0749       InternalSwap(&from);
0750     } else {
0751       CopyFrom(from);
0752     }
0753     return *this;
0754   }
0755
0756   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0757       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0758     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0759   }
0760   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0761       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0762     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0763   }
0764
0765   static const ::google::protobuf::Descriptor* descriptor() {
0766     return GetDescriptor();
0767   }
0768   static const ::google::protobuf::Descriptor* GetDescriptor() {
0769     return default_instance().GetMetadata().descriptor;
0770   }
0771   static const ::google::protobuf::Reflection* GetReflection() {
0772     return default_instance().GetMetadata().reflection;
0773   }
0774   static const SequenceProto& default_instance() {
0775     return *internal_default_instance();
0776   }
0777   static inline const SequenceProto* internal_default_instance() {
0778     return reinterpret_cast<const SequenceProto*>(
0779         &_SequenceProto_default_instance_);
0780   }
0781   static constexpr int kIndexInFileMessages = 0;
0782   friend void swap(SequenceProto& a, SequenceProto& b) { a.Swap(&b); }
0783   inline void Swap(SequenceProto* other) {
0784     if (other == this) return;
0785 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0786     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0787 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0788     if (GetArena() == other->GetArena()) {
0789 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0790       InternalSwap(other);
0791     } else {
0792       ::google::protobuf::internal::GenericSwap(this, other);
0793     }
0794   }
0795   void UnsafeArenaSwap(SequenceProto* other) {
0796     if (other == this) return;
0797     ABSL_DCHECK(GetArena() == other->GetArena());
0798     InternalSwap(other);
0799   }
0800
0801   // implements Message ----------------------------------------------
0802
0803   SequenceProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0804     return ::google::protobuf::Message::DefaultConstruct<SequenceProto>(arena);
0805   }
0806   using ::google::protobuf::Message::CopyFrom;
0807   void CopyFrom(const SequenceProto& from);
0808   using ::google::protobuf::Message::MergeFrom;
0809   void MergeFrom(const SequenceProto& from) { SequenceProto::MergeImpl(*this, from); }
0810
0811   private:
0812   static void MergeImpl(
0813       ::google::protobuf::MessageLite& to_msg,
0814       const ::google::protobuf::MessageLite& from_msg);
0815
0816   public:
0817   bool IsInitialized() const {
0818     return true;
0819   }
0820   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0821   #if defined(PROTOBUF_CUSTOM_VTABLE)
0822   private:
0823   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0824   static ::uint8_t* _InternalSerialize(
0825       const MessageLite& msg, ::uint8_t* target,
0826       ::google::protobuf::io::EpsCopyOutputStream* stream);
0827
0828   public:
0829   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0830   ::uint8_t* _InternalSerialize(
0831       ::uint8_t* target,
0832       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0833     return _InternalSerialize(*this, target, stream);
0834   }
0835   #else   // PROTOBUF_CUSTOM_VTABLE
0836   ::size_t ByteSizeLong() const final;
0837   ::uint8_t* _InternalSerialize(
0838       ::uint8_t* target,
0839       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0840   #endif  // PROTOBUF_CUSTOM_VTABLE
0841   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0842
0843   private:
0844   void SharedCtor(::google::protobuf::Arena* arena);
0845   void SharedDtor();
0846   void InternalSwap(SequenceProto* other);
0847  private:
0848   friend class ::google::protobuf::internal::AnyMetadata;
0849   static ::absl::string_view FullMessageName() { return "onnx.SequenceProto"; }
0850
0851  protected:
0852   explicit SequenceProto(::google::protobuf::Arena* arena);
0853   SequenceProto(::google::protobuf::Arena* arena, const SequenceProto& from);
0854   SequenceProto(::google::protobuf::Arena* arena, SequenceProto&& from) noexcept
0855       : SequenceProto(arena) {
0856     *this = ::std::move(from);
0857   }
0858   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0859   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0860
0861  public:
0862   ::google::protobuf::Metadata GetMetadata() const;
0863   // nested types ----------------------------------------------------
0864   using DataType = SequenceProto_DataType;
0865   static constexpr DataType UNDEFINED = SequenceProto_DataType_UNDEFINED;
0866   static constexpr DataType TENSOR = SequenceProto_DataType_TENSOR;
0867   static constexpr DataType SPARSE_TENSOR = SequenceProto_DataType_SPARSE_TENSOR;
0868   static constexpr DataType SEQUENCE = SequenceProto_DataType_SEQUENCE;
0869   static constexpr DataType MAP = SequenceProto_DataType_MAP;
0870   static constexpr DataType OPTIONAL = SequenceProto_DataType_OPTIONAL;
0871   static inline bool DataType_IsValid(int value) {
0872     return SequenceProto_DataType_IsValid(value);
0873   }
0874   static constexpr DataType DataType_MIN = SequenceProto_DataType_DataType_MIN;
0875   static constexpr DataType DataType_MAX = SequenceProto_DataType_DataType_MAX;
0876   static constexpr int DataType_ARRAYSIZE = SequenceProto_DataType_DataType_ARRAYSIZE;
0877   static inline const ::google::protobuf::EnumDescriptor* DataType_descriptor() {
0878     return SequenceProto_DataType_descriptor();
0879   }
0880   template <typename T>
0881   static inline const std::string& DataType_Name(T value) {
0882     return SequenceProto_DataType_Name(value);
0883   }
0884   static inline bool DataType_Parse(absl::string_view name, DataType* value) {
0885     return SequenceProto_DataType_Parse(name, value);
0886   }
0887
0888   // accessors -------------------------------------------------------
0889   enum : int {
0890     kTensorValuesFieldNumber = 3,
0891     kSparseTensorValuesFieldNumber = 4,
0892     kSequenceValuesFieldNumber = 5,
0893     kMapValuesFieldNumber = 6,
0894     kOptionalValuesFieldNumber = 7,
0895     kNameFieldNumber = 1,
0896     kElemTypeFieldNumber = 2,
0897   };
0898   // repeated .onnx.TensorProto tensor_values = 3;
0899   int tensor_values_size() const;
0900   private:
0901   int _internal_tensor_values_size() const;
0902
0903   public:
0904   void clear_tensor_values() ;
0905   ::onnx::TensorProto* mutable_tensor_values(int index);
0906   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* mutable_tensor_values();
0907
0908   private:
0909   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& _internal_tensor_values() const;
0910   ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* _internal_mutable_tensor_values();
0911   public:
0912   const ::onnx::TensorProto& tensor_values(int index) const;
0913   ::onnx::TensorProto* add_tensor_values();
0914   const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& tensor_values() const;
0915   // repeated .onnx.SparseTensorProto sparse_tensor_values = 4;
0916   int sparse_tensor_values_size() const;
0917   private:
0918   int _internal_sparse_tensor_values_size() const;
0919
0920   public:
0921   void clear_sparse_tensor_values() ;
0922   ::onnx::SparseTensorProto* mutable_sparse_tensor_values(int index);
0923   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* mutable_sparse_tensor_values();
0924
0925   private:
0926   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& _internal_sparse_tensor_values() const;
0927   ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* _internal_mutable_sparse_tensor_values();
0928   public:
0929   const ::onnx::SparseTensorProto& sparse_tensor_values(int index) const;
0930   ::onnx::SparseTensorProto* add_sparse_tensor_values();
0931   const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& sparse_tensor_values() const;
0932   // repeated .onnx.SequenceProto sequence_values = 5;
0933   int sequence_values_size() const;
0934   private:
0935   int _internal_sequence_values_size() const;
0936
0937   public:
0938   void clear_sequence_values() ;
0939   ::onnx::SequenceProto* mutable_sequence_values(int index);
0940   ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* mutable_sequence_values();
0941
0942   private:
0943   const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& _internal_sequence_values() const;
0944   ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* _internal_mutable_sequence_values();
0945   public:
0946   const ::onnx::SequenceProto& sequence_values(int index) const;
0947   ::onnx::SequenceProto* add_sequence_values();
0948   const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& sequence_values() const;
0949   // repeated .onnx.MapProto map_values = 6;
0950   int map_values_size() const;
0951   private:
0952   int _internal_map_values_size() const;
0953
0954   public:
0955   void clear_map_values() ;
0956   ::onnx::MapProto* mutable_map_values(int index);
0957   ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* mutable_map_values();
0958
0959   private:
0960   const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& _internal_map_values() const;
0961   ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* _internal_mutable_map_values();
0962   public:
0963   const ::onnx::MapProto& map_values(int index) const;
0964   ::onnx::MapProto* add_map_values();
0965   const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& map_values() const;
0966   // repeated .onnx.OptionalProto optional_values = 7;
0967   int optional_values_size() const;
0968   private:
0969   int _internal_optional_values_size() const;
0970
0971   public:
0972   void clear_optional_values() ;
0973   ::onnx::OptionalProto* mutable_optional_values(int index);
0974   ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* mutable_optional_values();
0975
0976   private:
0977   const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& _internal_optional_values() const;
0978   ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* _internal_mutable_optional_values();
0979   public:
0980   const ::onnx::OptionalProto& optional_values(int index) const;
0981   ::onnx::OptionalProto* add_optional_values();
0982   const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& optional_values() const;
0983   // optional string name = 1;
0984   bool has_name() const;
0985   void clear_name() ;
0986   const std::string& name() const;
0987   template <typename Arg_ = const std::string&, typename... Args_>
0988   void set_name(Arg_&& arg, Args_... args);
0989   std::string* mutable_name();
0990   PROTOBUF_NODISCARD std::string* release_name();
0991   void set_allocated_name(std::string* value);
0992
0993   private:
0994   const std::string& _internal_name() const;
0995   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
0996       const std::string& value);
0997   std::string* _internal_mutable_name();
0998
0999   public:
1000   // optional int32 elem_type = 2;
1001   bool has_elem_type() const;
1002   void clear_elem_type() ;
1003   ::int32_t elem_type() const;
1004   void set_elem_type(::int32_t value);
1005
1006   private:
1007   ::int32_t _internal_elem_type() const;
1008   void _internal_set_elem_type(::int32_t value);
1009
1010   public:
1011   // @@protoc_insertion_point(class_scope:onnx.SequenceProto)
1012  private:
1013   class _Internal;
1014   friend class ::google::protobuf::internal::TcParser;
1015   static const ::google::protobuf::internal::TcParseTable<
1016       3, 7, 5,
1017       31, 2>
1018       _table_;
1019
1020
1021   friend class ::google::protobuf::MessageLite;
1022   friend class ::google::protobuf::Arena;
1023   template <typename T>
1024   friend class ::google::protobuf::Arena::InternalHelper;
1025   using InternalArenaConstructable_ = void;
1026   using DestructorSkippable_ = void;
1027   struct Impl_ {
1028     inline explicit constexpr Impl_(
1029         ::google::protobuf::internal::ConstantInitialized) noexcept;
1030     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1031                           ::google::protobuf::Arena* arena);
1032     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
1033                           ::google::protobuf::Arena* arena, const Impl_& from,
1034                           const SequenceProto& from_msg);
1035     ::google::protobuf::internal::HasBits<1> _has_bits_;
1036     mutable ::google::protobuf::internal::CachedSize _cached_size_;
1037     ::google::protobuf::RepeatedPtrField< ::onnx::TensorProto > tensor_values_;
1038     ::google::protobuf::RepeatedPtrField< ::onnx::SparseTensorProto > sparse_tensor_values_;
1039     ::google::protobuf::RepeatedPtrField< ::onnx::SequenceProto > sequence_values_;
1040     ::google::protobuf::RepeatedPtrField< ::onnx::MapProto > map_values_;
1041     ::google::protobuf::RepeatedPtrField< ::onnx::OptionalProto > optional_values_;
1042     ::google::protobuf::internal::ArenaStringPtr name_;
1043     ::int32_t elem_type_;
1044     PROTOBUF_TSAN_DECLARE_MEMBER
1045   };
1046   union { Impl_ _impl_; };
1047   friend struct ::TableStruct_onnx_2fonnx_2ddata_2eproto;
1048 };
1049
1050 // ===================================================================
1051
1052
1053
1054
1055 // ===================================================================
1056
1057
1058 #ifdef __GNUC__
1059 #pragma GCC diagnostic push
1060 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1061 #endif  // __GNUC__
1062 // -------------------------------------------------------------------
1063
1064 // SequenceProto
1065
1066 // optional string name = 1;
1067 inline bool SequenceProto::has_name() const {
1068   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1069   return value;
1070 }
1071 inline void SequenceProto::clear_name() {
1072   ::google::protobuf::internal::TSanWrite(&_impl_);
1073   _impl_.name_.ClearToEmpty();
1074   _impl_._has_bits_[0] &= ~0x00000001u;
1075 }
1076 inline const std::string& SequenceProto::name() const
1077     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1078   // @@protoc_insertion_point(field_get:onnx.SequenceProto.name)
1079   return _internal_name();
1080 }
1081 template <typename Arg_, typename... Args_>
1082 inline PROTOBUF_ALWAYS_INLINE void SequenceProto::set_name(Arg_&& arg,
1083                                                      Args_... args) {
1084   ::google::protobuf::internal::TSanWrite(&_impl_);
1085   _impl_._has_bits_[0] |= 0x00000001u;
1086   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1087   // @@protoc_insertion_point(field_set:onnx.SequenceProto.name)
1088 }
1089 inline std::string* SequenceProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1090   std::string* _s = _internal_mutable_name();
1091   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.name)
1092   return _s;
1093 }
1094 inline const std::string& SequenceProto::_internal_name() const {
1095   ::google::protobuf::internal::TSanRead(&_impl_);
1096   return _impl_.name_.Get();
1097 }
1098 inline void SequenceProto::_internal_set_name(const std::string& value) {
1099   ::google::protobuf::internal::TSanWrite(&_impl_);
1100   _impl_._has_bits_[0] |= 0x00000001u;
1101   _impl_.name_.Set(value, GetArena());
1102 }
1103 inline std::string* SequenceProto::_internal_mutable_name() {
1104   ::google::protobuf::internal::TSanWrite(&_impl_);
1105   _impl_._has_bits_[0] |= 0x00000001u;
1106   return _impl_.name_.Mutable( GetArena());
1107 }
1108 inline std::string* SequenceProto::release_name() {
1109   ::google::protobuf::internal::TSanWrite(&_impl_);
1110   // @@protoc_insertion_point(field_release:onnx.SequenceProto.name)
1111   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
1112     return nullptr;
1113   }
1114   _impl_._has_bits_[0] &= ~0x00000001u;
1115   auto* released = _impl_.name_.Release();
1116   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1117   _impl_.name_.Set("", GetArena());
1118   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1119   return released;
1120 }
1121 inline void SequenceProto::set_allocated_name(std::string* value) {
1122   ::google::protobuf::internal::TSanWrite(&_impl_);
1123   if (value != nullptr) {
1124     _impl_._has_bits_[0] |= 0x00000001u;
1125   } else {
1126     _impl_._has_bits_[0] &= ~0x00000001u;
1127   }
1128   _impl_.name_.SetAllocated(value, GetArena());
1129   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1130         if (_impl_.name_.IsDefault()) {
1131           _impl_.name_.Set("", GetArena());
1132         }
1133   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1134   // @@protoc_insertion_point(field_set_allocated:onnx.SequenceProto.name)
1135 }
1136
1137 // optional int32 elem_type = 2;
1138 inline bool SequenceProto::has_elem_type() const {
1139   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1140   return value;
1141 }
1142 inline void SequenceProto::clear_elem_type() {
1143   ::google::protobuf::internal::TSanWrite(&_impl_);
1144   _impl_.elem_type_ = 0;
1145   _impl_._has_bits_[0] &= ~0x00000002u;
1146 }
1147 inline ::int32_t SequenceProto::elem_type() const {
1148   // @@protoc_insertion_point(field_get:onnx.SequenceProto.elem_type)
1149   return _internal_elem_type();
1150 }
1151 inline void SequenceProto::set_elem_type(::int32_t value) {
1152   _internal_set_elem_type(value);
1153   _impl_._has_bits_[0] |= 0x00000002u;
1154   // @@protoc_insertion_point(field_set:onnx.SequenceProto.elem_type)
1155 }
1156 inline ::int32_t SequenceProto::_internal_elem_type() const {
1157   ::google::protobuf::internal::TSanRead(&_impl_);
1158   return _impl_.elem_type_;
1159 }
1160 inline void SequenceProto::_internal_set_elem_type(::int32_t value) {
1161   ::google::protobuf::internal::TSanWrite(&_impl_);
1162   _impl_.elem_type_ = value;
1163 }
1164
1165 // repeated .onnx.TensorProto tensor_values = 3;
1166 inline int SequenceProto::_internal_tensor_values_size() const {
1167   return _internal_tensor_values().size();
1168 }
1169 inline int SequenceProto::tensor_values_size() const {
1170   return _internal_tensor_values_size();
1171 }
1172 inline ::onnx::TensorProto* SequenceProto::mutable_tensor_values(int index)
1173     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1174   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.tensor_values)
1175   return _internal_mutable_tensor_values()->Mutable(index);
1176 }
1177 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>* SequenceProto::mutable_tensor_values()
1178     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1179   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.tensor_values)
1180   ::google::protobuf::internal::TSanWrite(&_impl_);
1181   return _internal_mutable_tensor_values();
1182 }
1183 inline const ::onnx::TensorProto& SequenceProto::tensor_values(int index) const
1184     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1185   // @@protoc_insertion_point(field_get:onnx.SequenceProto.tensor_values)
1186   return _internal_tensor_values().Get(index);
1187 }
1188 inline ::onnx::TensorProto* SequenceProto::add_tensor_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1189   ::google::protobuf::internal::TSanWrite(&_impl_);
1190   ::onnx::TensorProto* _add = _internal_mutable_tensor_values()->Add();
1191   // @@protoc_insertion_point(field_add:onnx.SequenceProto.tensor_values)
1192   return _add;
1193 }
1194 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>& SequenceProto::tensor_values() const
1195     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1196   // @@protoc_insertion_point(field_list:onnx.SequenceProto.tensor_values)
1197   return _internal_tensor_values();
1198 }
1199 inline const ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>&
1200 SequenceProto::_internal_tensor_values() const {
1201   ::google::protobuf::internal::TSanRead(&_impl_);
1202   return _impl_.tensor_values_;
1203 }
1204 inline ::google::protobuf::RepeatedPtrField<::onnx::TensorProto>*
1205 SequenceProto::_internal_mutable_tensor_values() {
1206   ::google::protobuf::internal::TSanRead(&_impl_);
1207   return &_impl_.tensor_values_;
1208 }
1209
1210 // repeated .onnx.SparseTensorProto sparse_tensor_values = 4;
1211 inline int SequenceProto::_internal_sparse_tensor_values_size() const {
1212   return _internal_sparse_tensor_values().size();
1213 }
1214 inline int SequenceProto::sparse_tensor_values_size() const {
1215   return _internal_sparse_tensor_values_size();
1216 }
1217 inline ::onnx::SparseTensorProto* SequenceProto::mutable_sparse_tensor_values(int index)
1218     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1219   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.sparse_tensor_values)
1220   return _internal_mutable_sparse_tensor_values()->Mutable(index);
1221 }
1222 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>* SequenceProto::mutable_sparse_tensor_values()
1223     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1224   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.sparse_tensor_values)
1225   ::google::protobuf::internal::TSanWrite(&_impl_);
1226   return _internal_mutable_sparse_tensor_values();
1227 }
1228 inline const ::onnx::SparseTensorProto& SequenceProto::sparse_tensor_values(int index) const
1229     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1230   // @@protoc_insertion_point(field_get:onnx.SequenceProto.sparse_tensor_values)
1231   return _internal_sparse_tensor_values().Get(index);
1232 }
1233 inline ::onnx::SparseTensorProto* SequenceProto::add_sparse_tensor_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1234   ::google::protobuf::internal::TSanWrite(&_impl_);
1235   ::onnx::SparseTensorProto* _add = _internal_mutable_sparse_tensor_values()->Add();
1236   // @@protoc_insertion_point(field_add:onnx.SequenceProto.sparse_tensor_values)
1237   return _add;
1238 }
1239 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>& SequenceProto::sparse_tensor_values() const
1240     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1241   // @@protoc_insertion_point(field_list:onnx.SequenceProto.sparse_tensor_values)
1242   return _internal_sparse_tensor_values();
1243 }
1244 inline const ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>&
1245 SequenceProto::_internal_sparse_tensor_values() const {
1246   ::google::protobuf::internal::TSanRead(&_impl_);
1247   return _impl_.sparse_tensor_values_;
1248 }
1249 inline ::google::protobuf::RepeatedPtrField<::onnx::SparseTensorProto>*
1250 SequenceProto::_internal_mutable_sparse_tensor_values() {
1251   ::google::protobuf::internal::TSanRead(&_impl_);
1252   return &_impl_.sparse_tensor_values_;
1253 }
1254
1255 // repeated .onnx.SequenceProto sequence_values = 5;
1256 inline int SequenceProto::_internal_sequence_values_size() const {
1257   return _internal_sequence_values().size();
1258 }
1259 inline int SequenceProto::sequence_values_size() const {
1260   return _internal_sequence_values_size();
1261 }
1262 inline void SequenceProto::clear_sequence_values() {
1263   ::google::protobuf::internal::TSanWrite(&_impl_);
1264   _impl_.sequence_values_.Clear();
1265 }
1266 inline ::onnx::SequenceProto* SequenceProto::mutable_sequence_values(int index)
1267     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1268   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.sequence_values)
1269   return _internal_mutable_sequence_values()->Mutable(index);
1270 }
1271 inline ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>* SequenceProto::mutable_sequence_values()
1272     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1273   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.sequence_values)
1274   ::google::protobuf::internal::TSanWrite(&_impl_);
1275   return _internal_mutable_sequence_values();
1276 }
1277 inline const ::onnx::SequenceProto& SequenceProto::sequence_values(int index) const
1278     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1279   // @@protoc_insertion_point(field_get:onnx.SequenceProto.sequence_values)
1280   return _internal_sequence_values().Get(index);
1281 }
1282 inline ::onnx::SequenceProto* SequenceProto::add_sequence_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1283   ::google::protobuf::internal::TSanWrite(&_impl_);
1284   ::onnx::SequenceProto* _add = _internal_mutable_sequence_values()->Add();
1285   // @@protoc_insertion_point(field_add:onnx.SequenceProto.sequence_values)
1286   return _add;
1287 }
1288 inline const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>& SequenceProto::sequence_values() const
1289     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1290   // @@protoc_insertion_point(field_list:onnx.SequenceProto.sequence_values)
1291   return _internal_sequence_values();
1292 }
1293 inline const ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>&
1294 SequenceProto::_internal_sequence_values() const {
1295   ::google::protobuf::internal::TSanRead(&_impl_);
1296   return _impl_.sequence_values_;
1297 }
1298 inline ::google::protobuf::RepeatedPtrField<::onnx::SequenceProto>*
1299 SequenceProto::_internal_mutable_sequence_values() {
1300   ::google::protobuf::internal::TSanRead(&_impl_);
1301   return &_impl_.sequence_values_;
1302 }
1303
1304 // repeated .onnx.MapProto map_values = 6;
1305 inline int SequenceProto::_internal_map_values_size() const {
1306   return _internal_map_values().size();
1307 }
1308 inline int SequenceProto::map_values_size() const {
1309   return _internal_map_values_size();
1310 }
1311 inline void SequenceProto::clear_map_values() {
1312   ::google::protobuf::internal::TSanWrite(&_impl_);
1313   _impl_.map_values_.Clear();
1314 }
1315 inline ::onnx::MapProto* SequenceProto::mutable_map_values(int index)
1316     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1317   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.map_values)
1318   return _internal_mutable_map_values()->Mutable(index);
1319 }
1320 inline ::google::protobuf::RepeatedPtrField<::onnx::MapProto>* SequenceProto::mutable_map_values()
1321     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1322   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.map_values)
1323   ::google::protobuf::internal::TSanWrite(&_impl_);
1324   return _internal_mutable_map_values();
1325 }
1326 inline const ::onnx::MapProto& SequenceProto::map_values(int index) const
1327     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1328   // @@protoc_insertion_point(field_get:onnx.SequenceProto.map_values)
1329   return _internal_map_values().Get(index);
1330 }
1331 inline ::onnx::MapProto* SequenceProto::add_map_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1332   ::google::protobuf::internal::TSanWrite(&_impl_);
1333   ::onnx::MapProto* _add = _internal_mutable_map_values()->Add();
1334   // @@protoc_insertion_point(field_add:onnx.SequenceProto.map_values)
1335   return _add;
1336 }
1337 inline const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>& SequenceProto::map_values() const
1338     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1339   // @@protoc_insertion_point(field_list:onnx.SequenceProto.map_values)
1340   return _internal_map_values();
1341 }
1342 inline const ::google::protobuf::RepeatedPtrField<::onnx::MapProto>&
1343 SequenceProto::_internal_map_values() const {
1344   ::google::protobuf::internal::TSanRead(&_impl_);
1345   return _impl_.map_values_;
1346 }
1347 inline ::google::protobuf::RepeatedPtrField<::onnx::MapProto>*
1348 SequenceProto::_internal_mutable_map_values() {
1349   ::google::protobuf::internal::TSanRead(&_impl_);
1350   return &_impl_.map_values_;
1351 }
1352
1353 // repeated .onnx.OptionalProto optional_values = 7;
1354 inline int SequenceProto::_internal_optional_values_size() const {
1355   return _internal_optional_values().size();
1356 }
1357 inline int SequenceProto::optional_values_size() const {
1358   return _internal_optional_values_size();
1359 }
1360 inline void SequenceProto::clear_optional_values() {
1361   ::google::protobuf::internal::TSanWrite(&_impl_);
1362   _impl_.optional_values_.Clear();
1363 }
1364 inline ::onnx::OptionalProto* SequenceProto::mutable_optional_values(int index)
1365     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1366   // @@protoc_insertion_point(field_mutable:onnx.SequenceProto.optional_values)
1367   return _internal_mutable_optional_values()->Mutable(index);
1368 }
1369 inline ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>* SequenceProto::mutable_optional_values()
1370     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1371   // @@protoc_insertion_point(field_mutable_list:onnx.SequenceProto.optional_values)
1372   ::google::protobuf::internal::TSanWrite(&_impl_);
1373   return _internal_mutable_optional_values();
1374 }
1375 inline const ::onnx::OptionalProto& SequenceProto::optional_values(int index) const
1376     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1377   // @@protoc_insertion_point(field_get:onnx.SequenceProto.optional_values)
1378   return _internal_optional_values().Get(index);
1379 }
1380 inline ::onnx::OptionalProto* SequenceProto::add_optional_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1381   ::google::protobuf::internal::TSanWrite(&_impl_);
1382   ::onnx::OptionalProto* _add = _internal_mutable_optional_values()->Add();
1383   // @@protoc_insertion_point(field_add:onnx.SequenceProto.optional_values)
1384   return _add;
1385 }
1386 inline const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>& SequenceProto::optional_values() const
1387     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1388   // @@protoc_insertion_point(field_list:onnx.SequenceProto.optional_values)
1389   return _internal_optional_values();
1390 }
1391 inline const ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>&
1392 SequenceProto::_internal_optional_values() const {
1393   ::google::protobuf::internal::TSanRead(&_impl_);
1394   return _impl_.optional_values_;
1395 }
1396 inline ::google::protobuf::RepeatedPtrField<::onnx::OptionalProto>*
1397 SequenceProto::_internal_mutable_optional_values() {
1398   ::google::protobuf::internal::TSanRead(&_impl_);
1399   return &_impl_.optional_values_;
1400 }
1401
1402 // -------------------------------------------------------------------
1403
1404 // MapProto
1405
1406 // optional string name = 1;
1407 inline bool MapProto::has_name() const {
1408   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1409   return value;
1410 }
1411 inline void MapProto::clear_name() {
1412   ::google::protobuf::internal::TSanWrite(&_impl_);
1413   _impl_.name_.ClearToEmpty();
1414   _impl_._has_bits_[0] &= ~0x00000001u;
1415 }
1416 inline const std::string& MapProto::name() const
1417     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1418   // @@protoc_insertion_point(field_get:onnx.MapProto.name)
1419   return _internal_name();
1420 }
1421 template <typename Arg_, typename... Args_>
1422 inline PROTOBUF_ALWAYS_INLINE void MapProto::set_name(Arg_&& arg,
1423                                                      Args_... args) {
1424   ::google::protobuf::internal::TSanWrite(&_impl_);
1425   _impl_._has_bits_[0] |= 0x00000001u;
1426   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1427   // @@protoc_insertion_point(field_set:onnx.MapProto.name)
1428 }
1429 inline std::string* MapProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1430   std::string* _s = _internal_mutable_name();
1431   // @@protoc_insertion_point(field_mutable:onnx.MapProto.name)
1432   return _s;
1433 }
1434 inline const std::string& MapProto::_internal_name() const {
1435   ::google::protobuf::internal::TSanRead(&_impl_);
1436   return _impl_.name_.Get();
1437 }
1438 inline void MapProto::_internal_set_name(const std::string& value) {
1439   ::google::protobuf::internal::TSanWrite(&_impl_);
1440   _impl_._has_bits_[0] |= 0x00000001u;
1441   _impl_.name_.Set(value, GetArena());
1442 }
1443 inline std::string* MapProto::_internal_mutable_name() {
1444   ::google::protobuf::internal::TSanWrite(&_impl_);
1445   _impl_._has_bits_[0] |= 0x00000001u;
1446   return _impl_.name_.Mutable( GetArena());
1447 }
1448 inline std::string* MapProto::release_name() {
1449   ::google::protobuf::internal::TSanWrite(&_impl_);
1450   // @@protoc_insertion_point(field_release:onnx.MapProto.name)
1451   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
1452     return nullptr;
1453   }
1454   _impl_._has_bits_[0] &= ~0x00000001u;
1455   auto* released = _impl_.name_.Release();
1456   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1457   _impl_.name_.Set("", GetArena());
1458   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1459   return released;
1460 }
1461 inline void MapProto::set_allocated_name(std::string* value) {
1462   ::google::protobuf::internal::TSanWrite(&_impl_);
1463   if (value != nullptr) {
1464     _impl_._has_bits_[0] |= 0x00000001u;
1465   } else {
1466     _impl_._has_bits_[0] &= ~0x00000001u;
1467   }
1468   _impl_.name_.SetAllocated(value, GetArena());
1469   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1470         if (_impl_.name_.IsDefault()) {
1471           _impl_.name_.Set("", GetArena());
1472         }
1473   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1474   // @@protoc_insertion_point(field_set_allocated:onnx.MapProto.name)
1475 }
1476
1477 // optional int32 key_type = 2;
1478 inline bool MapProto::has_key_type() const {
1479   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1480   return value;
1481 }
1482 inline void MapProto::clear_key_type() {
1483   ::google::protobuf::internal::TSanWrite(&_impl_);
1484   _impl_.key_type_ = 0;
1485   _impl_._has_bits_[0] &= ~0x00000004u;
1486 }
1487 inline ::int32_t MapProto::key_type() const {
1488   // @@protoc_insertion_point(field_get:onnx.MapProto.key_type)
1489   return _internal_key_type();
1490 }
1491 inline void MapProto::set_key_type(::int32_t value) {
1492   _internal_set_key_type(value);
1493   _impl_._has_bits_[0] |= 0x00000004u;
1494   // @@protoc_insertion_point(field_set:onnx.MapProto.key_type)
1495 }
1496 inline ::int32_t MapProto::_internal_key_type() const {
1497   ::google::protobuf::internal::TSanRead(&_impl_);
1498   return _impl_.key_type_;
1499 }
1500 inline void MapProto::_internal_set_key_type(::int32_t value) {
1501   ::google::protobuf::internal::TSanWrite(&_impl_);
1502   _impl_.key_type_ = value;
1503 }
1504
1505 // repeated int64 keys = 3;
1506 inline int MapProto::_internal_keys_size() const {
1507   return _internal_keys().size();
1508 }
1509 inline int MapProto::keys_size() const {
1510   return _internal_keys_size();
1511 }
1512 inline void MapProto::clear_keys() {
1513   ::google::protobuf::internal::TSanWrite(&_impl_);
1514   _impl_.keys_.Clear();
1515 }
1516 inline ::int64_t MapProto::keys(int index) const {
1517   // @@protoc_insertion_point(field_get:onnx.MapProto.keys)
1518   return _internal_keys().Get(index);
1519 }
1520 inline void MapProto::set_keys(int index, ::int64_t value) {
1521   _internal_mutable_keys()->Set(index, value);
1522   // @@protoc_insertion_point(field_set:onnx.MapProto.keys)
1523 }
1524 inline void MapProto::add_keys(::int64_t value) {
1525   ::google::protobuf::internal::TSanWrite(&_impl_);
1526   _internal_mutable_keys()->Add(value);
1527   // @@protoc_insertion_point(field_add:onnx.MapProto.keys)
1528 }
1529 inline const ::google::protobuf::RepeatedField<::int64_t>& MapProto::keys() const
1530     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1531   // @@protoc_insertion_point(field_list:onnx.MapProto.keys)
1532   return _internal_keys();
1533 }
1534 inline ::google::protobuf::RepeatedField<::int64_t>* MapProto::mutable_keys()
1535     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1536   // @@protoc_insertion_point(field_mutable_list:onnx.MapProto.keys)
1537   ::google::protobuf::internal::TSanWrite(&_impl_);
1538   return _internal_mutable_keys();
1539 }
1540 inline const ::google::protobuf::RepeatedField<::int64_t>&
1541 MapProto::_internal_keys() const {
1542   ::google::protobuf::internal::TSanRead(&_impl_);
1543   return _impl_.keys_;
1544 }
1545 inline ::google::protobuf::RepeatedField<::int64_t>* MapProto::_internal_mutable_keys() {
1546   ::google::protobuf::internal::TSanRead(&_impl_);
1547   return &_impl_.keys_;
1548 }
1549
1550 // repeated bytes string_keys = 4;
1551 inline int MapProto::_internal_string_keys_size() const {
1552   return _internal_string_keys().size();
1553 }
1554 inline int MapProto::string_keys_size() const {
1555   return _internal_string_keys_size();
1556 }
1557 inline void MapProto::clear_string_keys() {
1558   ::google::protobuf::internal::TSanWrite(&_impl_);
1559   _impl_.string_keys_.Clear();
1560 }
1561 inline std::string* MapProto::add_string_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1562   ::google::protobuf::internal::TSanWrite(&_impl_);
1563   std::string* _s = _internal_mutable_string_keys()->Add();
1564   // @@protoc_insertion_point(field_add_mutable:onnx.MapProto.string_keys)
1565   return _s;
1566 }
1567 inline const std::string& MapProto::string_keys(int index) const
1568     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1569   // @@protoc_insertion_point(field_get:onnx.MapProto.string_keys)
1570   return _internal_string_keys().Get(index);
1571 }
1572 inline std::string* MapProto::mutable_string_keys(int index)
1573     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1574   // @@protoc_insertion_point(field_mutable:onnx.MapProto.string_keys)
1575   return _internal_mutable_string_keys()->Mutable(index);
1576 }
1577 template <typename Arg_, typename... Args_>
1578 inline void MapProto::set_string_keys(int index, Arg_&& value, Args_... args) {
1579   ::google::protobuf::internal::AssignToString(
1580       *_internal_mutable_string_keys()->Mutable(index),
1581       std::forward<Arg_>(value), args... , ::google::protobuf::internal::BytesTag{});
1582   // @@protoc_insertion_point(field_set:onnx.MapProto.string_keys)
1583 }
1584 template <typename Arg_, typename... Args_>
1585 inline void MapProto::add_string_keys(Arg_&& value, Args_... args) {
1586   ::google::protobuf::internal::TSanWrite(&_impl_);
1587   ::google::protobuf::internal::AddToRepeatedPtrField(*_internal_mutable_string_keys(),
1588                                std::forward<Arg_>(value),
1589                                args... , ::google::protobuf::internal::BytesTag{});
1590   // @@protoc_insertion_point(field_add:onnx.MapProto.string_keys)
1591 }
1592 inline const ::google::protobuf::RepeatedPtrField<std::string>&
1593 MapProto::string_keys() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1594   // @@protoc_insertion_point(field_list:onnx.MapProto.string_keys)
1595   return _internal_string_keys();
1596 }
1597 inline ::google::protobuf::RepeatedPtrField<std::string>*
1598 MapProto::mutable_string_keys() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1599   // @@protoc_insertion_point(field_mutable_list:onnx.MapProto.string_keys)
1600   ::google::protobuf::internal::TSanWrite(&_impl_);
1601   return _internal_mutable_string_keys();
1602 }
1603 inline const ::google::protobuf::RepeatedPtrField<std::string>&
1604 MapProto::_internal_string_keys() const {
1605   ::google::protobuf::internal::TSanRead(&_impl_);
1606   return _impl_.string_keys_;
1607 }
1608 inline ::google::protobuf::RepeatedPtrField<std::string>*
1609 MapProto::_internal_mutable_string_keys() {
1610   ::google::protobuf::internal::TSanRead(&_impl_);
1611   return &_impl_.string_keys_;
1612 }
1613
1614 // optional .onnx.SequenceProto values = 5;
1615 inline bool MapProto::has_values() const {
1616   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1617   PROTOBUF_ASSUME(!value || _impl_.values_ != nullptr);
1618   return value;
1619 }
1620 inline void MapProto::clear_values() {
1621   ::google::protobuf::internal::TSanWrite(&_impl_);
1622   if (_impl_.values_ != nullptr) _impl_.values_->Clear();
1623   _impl_._has_bits_[0] &= ~0x00000002u;
1624 }
1625 inline const ::onnx::SequenceProto& MapProto::_internal_values() const {
1626   ::google::protobuf::internal::TSanRead(&_impl_);
1627   const ::onnx::SequenceProto* p = _impl_.values_;
1628   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SequenceProto&>(::onnx::_SequenceProto_default_instance_);
1629 }
1630 inline const ::onnx::SequenceProto& MapProto::values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1631   // @@protoc_insertion_point(field_get:onnx.MapProto.values)
1632   return _internal_values();
1633 }
1634 inline void MapProto::unsafe_arena_set_allocated_values(::onnx::SequenceProto* value) {
1635   ::google::protobuf::internal::TSanWrite(&_impl_);
1636   if (GetArena() == nullptr) {
1637     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.values_);
1638   }
1639   _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(value);
1640   if (value != nullptr) {
1641     _impl_._has_bits_[0] |= 0x00000002u;
1642   } else {
1643     _impl_._has_bits_[0] &= ~0x00000002u;
1644   }
1645   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.MapProto.values)
1646 }
1647 inline ::onnx::SequenceProto* MapProto::release_values() {
1648   ::google::protobuf::internal::TSanWrite(&_impl_);
1649
1650   _impl_._has_bits_[0] &= ~0x00000002u;
1651   ::onnx::SequenceProto* released = _impl_.values_;
1652   _impl_.values_ = nullptr;
1653 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1654   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1655   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1656   if (GetArena() == nullptr) {
1657     delete old;
1658   }
1659 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
1660   if (GetArena() != nullptr) {
1661     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1662   }
1663 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
1664   return released;
1665 }
1666 inline ::onnx::SequenceProto* MapProto::unsafe_arena_release_values() {
1667   ::google::protobuf::internal::TSanWrite(&_impl_);
1668   // @@protoc_insertion_point(field_release:onnx.MapProto.values)
1669
1670   _impl_._has_bits_[0] &= ~0x00000002u;
1671   ::onnx::SequenceProto* temp = _impl_.values_;
1672   _impl_.values_ = nullptr;
1673   return temp;
1674 }
1675 inline ::onnx::SequenceProto* MapProto::_internal_mutable_values() {
1676   ::google::protobuf::internal::TSanWrite(&_impl_);
1677   if (_impl_.values_ == nullptr) {
1678     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SequenceProto>(GetArena());
1679     _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(p);
1680   }
1681   return _impl_.values_;
1682 }
1683 inline ::onnx::SequenceProto* MapProto::mutable_values() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1684   _impl_._has_bits_[0] |= 0x00000002u;
1685   ::onnx::SequenceProto* _msg = _internal_mutable_values();
1686   // @@protoc_insertion_point(field_mutable:onnx.MapProto.values)
1687   return _msg;
1688 }
1689 inline void MapProto::set_allocated_values(::onnx::SequenceProto* value) {
1690   ::google::protobuf::Arena* message_arena = GetArena();
1691   ::google::protobuf::internal::TSanWrite(&_impl_);
1692   if (message_arena == nullptr) {
1693     delete (_impl_.values_);
1694   }
1695
1696   if (value != nullptr) {
1697     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
1698     if (message_arena != submessage_arena) {
1699       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
1700     }
1701     _impl_._has_bits_[0] |= 0x00000002u;
1702   } else {
1703     _impl_._has_bits_[0] &= ~0x00000002u;
1704   }
1705
1706   _impl_.values_ = reinterpret_cast<::onnx::SequenceProto*>(value);
1707   // @@protoc_insertion_point(field_set_allocated:onnx.MapProto.values)
1708 }
1709
1710 // -------------------------------------------------------------------
1711
1712 // OptionalProto
1713
1714 // optional string name = 1;
1715 inline bool OptionalProto::has_name() const {
1716   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1717   return value;
1718 }
1719 inline void OptionalProto::clear_name() {
1720   ::google::protobuf::internal::TSanWrite(&_impl_);
1721   _impl_.name_.ClearToEmpty();
1722   _impl_._has_bits_[0] &= ~0x00000001u;
1723 }
1724 inline const std::string& OptionalProto::name() const
1725     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1726   // @@protoc_insertion_point(field_get:onnx.OptionalProto.name)
1727   return _internal_name();
1728 }
1729 template <typename Arg_, typename... Args_>
1730 inline PROTOBUF_ALWAYS_INLINE void OptionalProto::set_name(Arg_&& arg,
1731                                                      Args_... args) {
1732   ::google::protobuf::internal::TSanWrite(&_impl_);
1733   _impl_._has_bits_[0] |= 0x00000001u;
1734   _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1735   // @@protoc_insertion_point(field_set:onnx.OptionalProto.name)
1736 }
1737 inline std::string* OptionalProto::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1738   std::string* _s = _internal_mutable_name();
1739   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.name)
1740   return _s;
1741 }
1742 inline const std::string& OptionalProto::_internal_name() const {
1743   ::google::protobuf::internal::TSanRead(&_impl_);
1744   return _impl_.name_.Get();
1745 }
1746 inline void OptionalProto::_internal_set_name(const std::string& value) {
1747   ::google::protobuf::internal::TSanWrite(&_impl_);
1748   _impl_._has_bits_[0] |= 0x00000001u;
1749   _impl_.name_.Set(value, GetArena());
1750 }
1751 inline std::string* OptionalProto::_internal_mutable_name() {
1752   ::google::protobuf::internal::TSanWrite(&_impl_);
1753   _impl_._has_bits_[0] |= 0x00000001u;
1754   return _impl_.name_.Mutable( GetArena());
1755 }
1756 inline std::string* OptionalProto::release_name() {
1757   ::google::protobuf::internal::TSanWrite(&_impl_);
1758   // @@protoc_insertion_point(field_release:onnx.OptionalProto.name)
1759   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
1760     return nullptr;
1761   }
1762   _impl_._has_bits_[0] &= ~0x00000001u;
1763   auto* released = _impl_.name_.Release();
1764   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1765   _impl_.name_.Set("", GetArena());
1766   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1767   return released;
1768 }
1769 inline void OptionalProto::set_allocated_name(std::string* value) {
1770   ::google::protobuf::internal::TSanWrite(&_impl_);
1771   if (value != nullptr) {
1772     _impl_._has_bits_[0] |= 0x00000001u;
1773   } else {
1774     _impl_._has_bits_[0] &= ~0x00000001u;
1775   }
1776   _impl_.name_.SetAllocated(value, GetArena());
1777   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1778         if (_impl_.name_.IsDefault()) {
1779           _impl_.name_.Set("", GetArena());
1780         }
1781   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1782   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.name)
1783 }
1784
1785 // optional int32 elem_type = 2;
1786 inline bool OptionalProto::has_elem_type() const {
1787   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
1788   return value;
1789 }
1790 inline void OptionalProto::clear_elem_type() {
1791   ::google::protobuf::internal::TSanWrite(&_impl_);
1792   _impl_.elem_type_ = 0;
1793   _impl_._has_bits_[0] &= ~0x00000040u;
1794 }
1795 inline ::int32_t OptionalProto::elem_type() const {
1796   // @@protoc_insertion_point(field_get:onnx.OptionalProto.elem_type)
1797   return _internal_elem_type();
1798 }
1799 inline void OptionalProto::set_elem_type(::int32_t value) {
1800   _internal_set_elem_type(value);
1801   _impl_._has_bits_[0] |= 0x00000040u;
1802   // @@protoc_insertion_point(field_set:onnx.OptionalProto.elem_type)
1803 }
1804 inline ::int32_t OptionalProto::_internal_elem_type() const {
1805   ::google::protobuf::internal::TSanRead(&_impl_);
1806   return _impl_.elem_type_;
1807 }
1808 inline void OptionalProto::_internal_set_elem_type(::int32_t value) {
1809   ::google::protobuf::internal::TSanWrite(&_impl_);
1810   _impl_.elem_type_ = value;
1811 }
1812
1813 // optional .onnx.TensorProto tensor_value = 3;
1814 inline bool OptionalProto::has_tensor_value() const {
1815   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1816   PROTOBUF_ASSUME(!value || _impl_.tensor_value_ != nullptr);
1817   return value;
1818 }
1819 inline const ::onnx::TensorProto& OptionalProto::_internal_tensor_value() const {
1820   ::google::protobuf::internal::TSanRead(&_impl_);
1821   const ::onnx::TensorProto* p = _impl_.tensor_value_;
1822   return p != nullptr ? *p : reinterpret_cast<const ::onnx::TensorProto&>(::onnx::_TensorProto_default_instance_);
1823 }
1824 inline const ::onnx::TensorProto& OptionalProto::tensor_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1825   // @@protoc_insertion_point(field_get:onnx.OptionalProto.tensor_value)
1826   return _internal_tensor_value();
1827 }
1828 inline void OptionalProto::unsafe_arena_set_allocated_tensor_value(::onnx::TensorProto* value) {
1829   ::google::protobuf::internal::TSanWrite(&_impl_);
1830   if (GetArena() == nullptr) {
1831     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tensor_value_);
1832   }
1833   _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(value);
1834   if (value != nullptr) {
1835     _impl_._has_bits_[0] |= 0x00000002u;
1836   } else {
1837     _impl_._has_bits_[0] &= ~0x00000002u;
1838   }
1839   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.tensor_value)
1840 }
1841 inline ::onnx::TensorProto* OptionalProto::release_tensor_value() {
1842   ::google::protobuf::internal::TSanWrite(&_impl_);
1843
1844   _impl_._has_bits_[0] &= ~0x00000002u;
1845   ::onnx::TensorProto* released = _impl_.tensor_value_;
1846   _impl_.tensor_value_ = nullptr;
1847 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1848   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1849   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1850   if (GetArena() == nullptr) {
1851     delete old;
1852   }
1853 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
1854   if (GetArena() != nullptr) {
1855     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1856   }
1857 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
1858   return released;
1859 }
1860 inline ::onnx::TensorProto* OptionalProto::unsafe_arena_release_tensor_value() {
1861   ::google::protobuf::internal::TSanWrite(&_impl_);
1862   // @@protoc_insertion_point(field_release:onnx.OptionalProto.tensor_value)
1863
1864   _impl_._has_bits_[0] &= ~0x00000002u;
1865   ::onnx::TensorProto* temp = _impl_.tensor_value_;
1866   _impl_.tensor_value_ = nullptr;
1867   return temp;
1868 }
1869 inline ::onnx::TensorProto* OptionalProto::_internal_mutable_tensor_value() {
1870   ::google::protobuf::internal::TSanWrite(&_impl_);
1871   if (_impl_.tensor_value_ == nullptr) {
1872     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::TensorProto>(GetArena());
1873     _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(p);
1874   }
1875   return _impl_.tensor_value_;
1876 }
1877 inline ::onnx::TensorProto* OptionalProto::mutable_tensor_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1878   _impl_._has_bits_[0] |= 0x00000002u;
1879   ::onnx::TensorProto* _msg = _internal_mutable_tensor_value();
1880   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.tensor_value)
1881   return _msg;
1882 }
1883 inline void OptionalProto::set_allocated_tensor_value(::onnx::TensorProto* value) {
1884   ::google::protobuf::Arena* message_arena = GetArena();
1885   ::google::protobuf::internal::TSanWrite(&_impl_);
1886   if (message_arena == nullptr) {
1887     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.tensor_value_);
1888   }
1889
1890   if (value != nullptr) {
1891     ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
1892     if (message_arena != submessage_arena) {
1893       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
1894     }
1895     _impl_._has_bits_[0] |= 0x00000002u;
1896   } else {
1897     _impl_._has_bits_[0] &= ~0x00000002u;
1898   }
1899
1900   _impl_.tensor_value_ = reinterpret_cast<::onnx::TensorProto*>(value);
1901   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.tensor_value)
1902 }
1903
1904 // optional .onnx.SparseTensorProto sparse_tensor_value = 4;
1905 inline bool OptionalProto::has_sparse_tensor_value() const {
1906   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1907   PROTOBUF_ASSUME(!value || _impl_.sparse_tensor_value_ != nullptr);
1908   return value;
1909 }
1910 inline const ::onnx::SparseTensorProto& OptionalProto::_internal_sparse_tensor_value() const {
1911   ::google::protobuf::internal::TSanRead(&_impl_);
1912   const ::onnx::SparseTensorProto* p = _impl_.sparse_tensor_value_;
1913   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SparseTensorProto&>(::onnx::_SparseTensorProto_default_instance_);
1914 }
1915 inline const ::onnx::SparseTensorProto& OptionalProto::sparse_tensor_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
1916   // @@protoc_insertion_point(field_get:onnx.OptionalProto.sparse_tensor_value)
1917   return _internal_sparse_tensor_value();
1918 }
1919 inline void OptionalProto::unsafe_arena_set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* value) {
1920   ::google::protobuf::internal::TSanWrite(&_impl_);
1921   if (GetArena() == nullptr) {
1922     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_value_);
1923   }
1924   _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
1925   if (value != nullptr) {
1926     _impl_._has_bits_[0] |= 0x00000004u;
1927   } else {
1928     _impl_._has_bits_[0] &= ~0x00000004u;
1929   }
1930   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.sparse_tensor_value)
1931 }
1932 inline ::onnx::SparseTensorProto* OptionalProto::release_sparse_tensor_value() {
1933   ::google::protobuf::internal::TSanWrite(&_impl_);
1934
1935   _impl_._has_bits_[0] &= ~0x00000004u;
1936   ::onnx::SparseTensorProto* released = _impl_.sparse_tensor_value_;
1937   _impl_.sparse_tensor_value_ = nullptr;
1938 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1939   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
1940   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1941   if (GetArena() == nullptr) {
1942     delete old;
1943   }
1944 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
1945   if (GetArena() != nullptr) {
1946     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
1947   }
1948 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
1949   return released;
1950 }
1951 inline ::onnx::SparseTensorProto* OptionalProto::unsafe_arena_release_sparse_tensor_value() {
1952   ::google::protobuf::internal::TSanWrite(&_impl_);
1953   // @@protoc_insertion_point(field_release:onnx.OptionalProto.sparse_tensor_value)
1954
1955   _impl_._has_bits_[0] &= ~0x00000004u;
1956   ::onnx::SparseTensorProto* temp = _impl_.sparse_tensor_value_;
1957   _impl_.sparse_tensor_value_ = nullptr;
1958   return temp;
1959 }
1960 inline ::onnx::SparseTensorProto* OptionalProto::_internal_mutable_sparse_tensor_value() {
1961   ::google::protobuf::internal::TSanWrite(&_impl_);
1962   if (_impl_.sparse_tensor_value_ == nullptr) {
1963     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SparseTensorProto>(GetArena());
1964     _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(p);
1965   }
1966   return _impl_.sparse_tensor_value_;
1967 }
1968 inline ::onnx::SparseTensorProto* OptionalProto::mutable_sparse_tensor_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1969   _impl_._has_bits_[0] |= 0x00000004u;
1970   ::onnx::SparseTensorProto* _msg = _internal_mutable_sparse_tensor_value();
1971   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.sparse_tensor_value)
1972   return _msg;
1973 }
1974 inline void OptionalProto::set_allocated_sparse_tensor_value(::onnx::SparseTensorProto* value) {
1975   ::google::protobuf::Arena* message_arena = GetArena();
1976   ::google::protobuf::internal::TSanWrite(&_impl_);
1977   if (message_arena == nullptr) {
1978     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sparse_tensor_value_);
1979   }
1980
1981   if (value != nullptr) {
1982     ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
1983     if (message_arena != submessage_arena) {
1984       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
1985     }
1986     _impl_._has_bits_[0] |= 0x00000004u;
1987   } else {
1988     _impl_._has_bits_[0] &= ~0x00000004u;
1989   }
1990
1991   _impl_.sparse_tensor_value_ = reinterpret_cast<::onnx::SparseTensorProto*>(value);
1992   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.sparse_tensor_value)
1993 }
1994
1995 // optional .onnx.SequenceProto sequence_value = 5;
1996 inline bool OptionalProto::has_sequence_value() const {
1997   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1998   PROTOBUF_ASSUME(!value || _impl_.sequence_value_ != nullptr);
1999   return value;
2000 }
2001 inline void OptionalProto::clear_sequence_value() {
2002   ::google::protobuf::internal::TSanWrite(&_impl_);
2003   if (_impl_.sequence_value_ != nullptr) _impl_.sequence_value_->Clear();
2004   _impl_._has_bits_[0] &= ~0x00000008u;
2005 }
2006 inline const ::onnx::SequenceProto& OptionalProto::_internal_sequence_value() const {
2007   ::google::protobuf::internal::TSanRead(&_impl_);
2008   const ::onnx::SequenceProto* p = _impl_.sequence_value_;
2009   return p != nullptr ? *p : reinterpret_cast<const ::onnx::SequenceProto&>(::onnx::_SequenceProto_default_instance_);
2010 }
2011 inline const ::onnx::SequenceProto& OptionalProto::sequence_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2012   // @@protoc_insertion_point(field_get:onnx.OptionalProto.sequence_value)
2013   return _internal_sequence_value();
2014 }
2015 inline void OptionalProto::unsafe_arena_set_allocated_sequence_value(::onnx::SequenceProto* value) {
2016   ::google::protobuf::internal::TSanWrite(&_impl_);
2017   if (GetArena() == nullptr) {
2018     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.sequence_value_);
2019   }
2020   _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(value);
2021   if (value != nullptr) {
2022     _impl_._has_bits_[0] |= 0x00000008u;
2023   } else {
2024     _impl_._has_bits_[0] &= ~0x00000008u;
2025   }
2026   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.sequence_value)
2027 }
2028 inline ::onnx::SequenceProto* OptionalProto::release_sequence_value() {
2029   ::google::protobuf::internal::TSanWrite(&_impl_);
2030
2031   _impl_._has_bits_[0] &= ~0x00000008u;
2032   ::onnx::SequenceProto* released = _impl_.sequence_value_;
2033   _impl_.sequence_value_ = nullptr;
2034 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2035   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2036   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2037   if (GetArena() == nullptr) {
2038     delete old;
2039   }
2040 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
2041   if (GetArena() != nullptr) {
2042     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2043   }
2044 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
2045   return released;
2046 }
2047 inline ::onnx::SequenceProto* OptionalProto::unsafe_arena_release_sequence_value() {
2048   ::google::protobuf::internal::TSanWrite(&_impl_);
2049   // @@protoc_insertion_point(field_release:onnx.OptionalProto.sequence_value)
2050
2051   _impl_._has_bits_[0] &= ~0x00000008u;
2052   ::onnx::SequenceProto* temp = _impl_.sequence_value_;
2053   _impl_.sequence_value_ = nullptr;
2054   return temp;
2055 }
2056 inline ::onnx::SequenceProto* OptionalProto::_internal_mutable_sequence_value() {
2057   ::google::protobuf::internal::TSanWrite(&_impl_);
2058   if (_impl_.sequence_value_ == nullptr) {
2059     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::SequenceProto>(GetArena());
2060     _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(p);
2061   }
2062   return _impl_.sequence_value_;
2063 }
2064 inline ::onnx::SequenceProto* OptionalProto::mutable_sequence_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
2065   _impl_._has_bits_[0] |= 0x00000008u;
2066   ::onnx::SequenceProto* _msg = _internal_mutable_sequence_value();
2067   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.sequence_value)
2068   return _msg;
2069 }
2070 inline void OptionalProto::set_allocated_sequence_value(::onnx::SequenceProto* value) {
2071   ::google::protobuf::Arena* message_arena = GetArena();
2072   ::google::protobuf::internal::TSanWrite(&_impl_);
2073   if (message_arena == nullptr) {
2074     delete (_impl_.sequence_value_);
2075   }
2076
2077   if (value != nullptr) {
2078     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
2079     if (message_arena != submessage_arena) {
2080       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2081     }
2082     _impl_._has_bits_[0] |= 0x00000008u;
2083   } else {
2084     _impl_._has_bits_[0] &= ~0x00000008u;
2085   }
2086
2087   _impl_.sequence_value_ = reinterpret_cast<::onnx::SequenceProto*>(value);
2088   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.sequence_value)
2089 }
2090
2091 // optional .onnx.MapProto map_value = 6;
2092 inline bool OptionalProto::has_map_value() const {
2093   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2094   PROTOBUF_ASSUME(!value || _impl_.map_value_ != nullptr);
2095   return value;
2096 }
2097 inline void OptionalProto::clear_map_value() {
2098   ::google::protobuf::internal::TSanWrite(&_impl_);
2099   if (_impl_.map_value_ != nullptr) _impl_.map_value_->Clear();
2100   _impl_._has_bits_[0] &= ~0x00000010u;
2101 }
2102 inline const ::onnx::MapProto& OptionalProto::_internal_map_value() const {
2103   ::google::protobuf::internal::TSanRead(&_impl_);
2104   const ::onnx::MapProto* p = _impl_.map_value_;
2105   return p != nullptr ? *p : reinterpret_cast<const ::onnx::MapProto&>(::onnx::_MapProto_default_instance_);
2106 }
2107 inline const ::onnx::MapProto& OptionalProto::map_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2108   // @@protoc_insertion_point(field_get:onnx.OptionalProto.map_value)
2109   return _internal_map_value();
2110 }
2111 inline void OptionalProto::unsafe_arena_set_allocated_map_value(::onnx::MapProto* value) {
2112   ::google::protobuf::internal::TSanWrite(&_impl_);
2113   if (GetArena() == nullptr) {
2114     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.map_value_);
2115   }
2116   _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(value);
2117   if (value != nullptr) {
2118     _impl_._has_bits_[0] |= 0x00000010u;
2119   } else {
2120     _impl_._has_bits_[0] &= ~0x00000010u;
2121   }
2122   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.map_value)
2123 }
2124 inline ::onnx::MapProto* OptionalProto::release_map_value() {
2125   ::google::protobuf::internal::TSanWrite(&_impl_);
2126
2127   _impl_._has_bits_[0] &= ~0x00000010u;
2128   ::onnx::MapProto* released = _impl_.map_value_;
2129   _impl_.map_value_ = nullptr;
2130 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2131   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2132   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2133   if (GetArena() == nullptr) {
2134     delete old;
2135   }
2136 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
2137   if (GetArena() != nullptr) {
2138     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2139   }
2140 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
2141   return released;
2142 }
2143 inline ::onnx::MapProto* OptionalProto::unsafe_arena_release_map_value() {
2144   ::google::protobuf::internal::TSanWrite(&_impl_);
2145   // @@protoc_insertion_point(field_release:onnx.OptionalProto.map_value)
2146
2147   _impl_._has_bits_[0] &= ~0x00000010u;
2148   ::onnx::MapProto* temp = _impl_.map_value_;
2149   _impl_.map_value_ = nullptr;
2150   return temp;
2151 }
2152 inline ::onnx::MapProto* OptionalProto::_internal_mutable_map_value() {
2153   ::google::protobuf::internal::TSanWrite(&_impl_);
2154   if (_impl_.map_value_ == nullptr) {
2155     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::MapProto>(GetArena());
2156     _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(p);
2157   }
2158   return _impl_.map_value_;
2159 }
2160 inline ::onnx::MapProto* OptionalProto::mutable_map_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
2161   _impl_._has_bits_[0] |= 0x00000010u;
2162   ::onnx::MapProto* _msg = _internal_mutable_map_value();
2163   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.map_value)
2164   return _msg;
2165 }
2166 inline void OptionalProto::set_allocated_map_value(::onnx::MapProto* value) {
2167   ::google::protobuf::Arena* message_arena = GetArena();
2168   ::google::protobuf::internal::TSanWrite(&_impl_);
2169   if (message_arena == nullptr) {
2170     delete (_impl_.map_value_);
2171   }
2172
2173   if (value != nullptr) {
2174     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
2175     if (message_arena != submessage_arena) {
2176       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2177     }
2178     _impl_._has_bits_[0] |= 0x00000010u;
2179   } else {
2180     _impl_._has_bits_[0] &= ~0x00000010u;
2181   }
2182
2183   _impl_.map_value_ = reinterpret_cast<::onnx::MapProto*>(value);
2184   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.map_value)
2185 }
2186
2187 // optional .onnx.OptionalProto optional_value = 7;
2188 inline bool OptionalProto::has_optional_value() const {
2189   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2190   PROTOBUF_ASSUME(!value || _impl_.optional_value_ != nullptr);
2191   return value;
2192 }
2193 inline void OptionalProto::clear_optional_value() {
2194   ::google::protobuf::internal::TSanWrite(&_impl_);
2195   if (_impl_.optional_value_ != nullptr) _impl_.optional_value_->Clear();
2196   _impl_._has_bits_[0] &= ~0x00000020u;
2197 }
2198 inline const ::onnx::OptionalProto& OptionalProto::_internal_optional_value() const {
2199   ::google::protobuf::internal::TSanRead(&_impl_);
2200   const ::onnx::OptionalProto* p = _impl_.optional_value_;
2201   return p != nullptr ? *p : reinterpret_cast<const ::onnx::OptionalProto&>(::onnx::_OptionalProto_default_instance_);
2202 }
2203 inline const ::onnx::OptionalProto& OptionalProto::optional_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
2204   // @@protoc_insertion_point(field_get:onnx.OptionalProto.optional_value)
2205   return _internal_optional_value();
2206 }
2207 inline void OptionalProto::unsafe_arena_set_allocated_optional_value(::onnx::OptionalProto* value) {
2208   ::google::protobuf::internal::TSanWrite(&_impl_);
2209   if (GetArena() == nullptr) {
2210     delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.optional_value_);
2211   }
2212   _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(value);
2213   if (value != nullptr) {
2214     _impl_._has_bits_[0] |= 0x00000020u;
2215   } else {
2216     _impl_._has_bits_[0] &= ~0x00000020u;
2217   }
2218   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.OptionalProto.optional_value)
2219 }
2220 inline ::onnx::OptionalProto* OptionalProto::release_optional_value() {
2221   ::google::protobuf::internal::TSanWrite(&_impl_);
2222
2223   _impl_._has_bits_[0] &= ~0x00000020u;
2224   ::onnx::OptionalProto* released = _impl_.optional_value_;
2225   _impl_.optional_value_ = nullptr;
2226 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2227   auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
2228   released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2229   if (GetArena() == nullptr) {
2230     delete old;
2231   }
2232 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
2233   if (GetArena() != nullptr) {
2234     released = ::google::protobuf::internal::DuplicateIfNonNull(released);
2235   }
2236 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
2237   return released;
2238 }
2239 inline ::onnx::OptionalProto* OptionalProto::unsafe_arena_release_optional_value() {
2240   ::google::protobuf::internal::TSanWrite(&_impl_);
2241   // @@protoc_insertion_point(field_release:onnx.OptionalProto.optional_value)
2242
2243   _impl_._has_bits_[0] &= ~0x00000020u;
2244   ::onnx::OptionalProto* temp = _impl_.optional_value_;
2245   _impl_.optional_value_ = nullptr;
2246   return temp;
2247 }
2248 inline ::onnx::OptionalProto* OptionalProto::_internal_mutable_optional_value() {
2249   ::google::protobuf::internal::TSanWrite(&_impl_);
2250   if (_impl_.optional_value_ == nullptr) {
2251     auto* p = ::google::protobuf::Message::DefaultConstruct<::onnx::OptionalProto>(GetArena());
2252     _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(p);
2253   }
2254   return _impl_.optional_value_;
2255 }
2256 inline ::onnx::OptionalProto* OptionalProto::mutable_optional_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
2257   _impl_._has_bits_[0] |= 0x00000020u;
2258   ::onnx::OptionalProto* _msg = _internal_mutable_optional_value();
2259   // @@protoc_insertion_point(field_mutable:onnx.OptionalProto.optional_value)
2260   return _msg;
2261 }
2262 inline void OptionalProto::set_allocated_optional_value(::onnx::OptionalProto* value) {
2263   ::google::protobuf::Arena* message_arena = GetArena();
2264   ::google::protobuf::internal::TSanWrite(&_impl_);
2265   if (message_arena == nullptr) {
2266     delete (_impl_.optional_value_);
2267   }
2268
2269   if (value != nullptr) {
2270     ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
2271     if (message_arena != submessage_arena) {
2272       value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
2273     }
2274     _impl_._has_bits_[0] |= 0x00000020u;
2275   } else {
2276     _impl_._has_bits_[0] &= ~0x00000020u;
2277   }
2278
2279   _impl_.optional_value_ = reinterpret_cast<::onnx::OptionalProto*>(value);
2280   // @@protoc_insertion_point(field_set_allocated:onnx.OptionalProto.optional_value)
2281 }
2282
2283 #ifdef __GNUC__
2284 #pragma GCC diagnostic pop
2285 #endif  // __GNUC__
2286
2287 // @@protoc_insertion_point(namespace_scope)
2288 }  // namespace onnx
2289
2290
2291 namespace google {
2292 namespace protobuf {
2293
2294 template <>
2295 struct is_proto_enum<::onnx::SequenceProto_DataType> : std::true_type {};
2296 template <>
2297 inline const EnumDescriptor* GetEnumDescriptor<::onnx::SequenceProto_DataType>() {
2298   return ::onnx::SequenceProto_DataType_descriptor();
2299 }
2300 template <>
2301 struct is_proto_enum<::onnx::OptionalProto_DataType> : std::true_type {};
2302 template <>
2303 inline const EnumDescriptor* GetEnumDescriptor<::onnx::OptionalProto_DataType>() {
2304   return ::onnx::OptionalProto_DataType_descriptor();
2305 }
2306
2307 }  // namespace protobuf
2308 }  // namespace google
2309
2310 // @@protoc_insertion_point(global_scope)
2311
2312 #include "google/protobuf/port_undef.inc"
2313
2314 #endif  // GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_2eproto_2epb_2eh