Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-02-21 10:05:44 

0001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
0002 // NO CHECKED-IN PROTOBUF GENCODE
0003 // source: onnx/onnx-operators-ml.proto
0004 // Protobuf C++ Version: 5.28.2
0005 
0006 #ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2doperators_2dml_2eproto_2epb_2eh
0007 #define GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2doperators_2dml_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/unknown_field_set.h"
0031 #include "onnx/onnx-ml.pb.h"
0032 // @@protoc_insertion_point(includes)
0033 
0034 // Must be included last.
0035 #include "google/protobuf/port_def.inc"
0036 
0037 #define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2doperators_2dml_2eproto ONNX_API
0038 
0039 namespace google {
0040 namespace protobuf {
0041 namespace internal {
0042 class AnyMetadata;
0043 }  // namespace internal
0044 }  // namespace protobuf
0045 }  // namespace google
0046 
0047 // Internal implementation detail -- do not use these members.
0048 struct ONNX_API TableStruct_onnx_2fonnx_2doperators_2dml_2eproto {
0049   static const ::uint32_t offsets[];
0050 };
0051 ONNX_API extern const ::google::protobuf::internal::DescriptorTable
0052     descriptor_table_onnx_2fonnx_2doperators_2dml_2eproto;
0053 namespace onnx {
0054 class OperatorProto;
0055 struct OperatorProtoDefaultTypeInternal;
0056 ONNX_API extern OperatorProtoDefaultTypeInternal _OperatorProto_default_instance_;
0057 class OperatorSetProto;
0058 struct OperatorSetProtoDefaultTypeInternal;
0059 ONNX_API extern OperatorSetProtoDefaultTypeInternal _OperatorSetProto_default_instance_;
0060 }  // namespace onnx
0061 namespace google {
0062 namespace protobuf {
0063 }  // namespace protobuf
0064 }  // namespace google
0065 
0066 namespace onnx {
0067 
0068 // ===================================================================
0069 
0070 
0071 // -------------------------------------------------------------------
0072 
0073 class ONNX_API OperatorProto final : public ::google::protobuf::Message
0074 /* @@protoc_insertion_point(class_definition:onnx.OperatorProto) */ {
0075  public:
0076   inline OperatorProto() : OperatorProto(nullptr) {}
0077   ~OperatorProto() PROTOBUF_FINAL;
0078   template <typename = void>
0079   explicit PROTOBUF_CONSTEXPR OperatorProto(
0080       ::google::protobuf::internal::ConstantInitialized);
0081 
0082   inline OperatorProto(const OperatorProto& from) : OperatorProto(nullptr, from) {}
0083   inline OperatorProto(OperatorProto&& from) noexcept
0084       : OperatorProto(nullptr, std::move(from)) {}
0085   inline OperatorProto& operator=(const OperatorProto& from) {
0086     CopyFrom(from);
0087     return *this;
0088   }
0089   inline OperatorProto& operator=(OperatorProto&& from) noexcept {
0090     if (this == &from) return *this;
0091     if (GetArena() == from.GetArena()
0092 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0093         && GetArena() != nullptr
0094 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0095     ) {
0096       InternalSwap(&from);
0097     } else {
0098       CopyFrom(from);
0099     }
0100     return *this;
0101   }
0102 
0103   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0104       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0105     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0106   }
0107   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0108       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0109     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0110   }
0111 
0112   static const ::google::protobuf::Descriptor* descriptor() {
0113     return GetDescriptor();
0114   }
0115   static const ::google::protobuf::Descriptor* GetDescriptor() {
0116     return default_instance().GetMetadata().descriptor;
0117   }
0118   static const ::google::protobuf::Reflection* GetReflection() {
0119     return default_instance().GetMetadata().reflection;
0120   }
0121   static const OperatorProto& default_instance() {
0122     return *internal_default_instance();
0123   }
0124   static inline const OperatorProto* internal_default_instance() {
0125     return reinterpret_cast<const OperatorProto*>(
0126         &_OperatorProto_default_instance_);
0127   }
0128   static constexpr int kIndexInFileMessages = 0;
0129   friend void swap(OperatorProto& a, OperatorProto& b) { a.Swap(&b); }
0130   inline void Swap(OperatorProto* other) {
0131     if (other == this) return;
0132 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0133     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0134 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0135     if (GetArena() == other->GetArena()) {
0136 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0137       InternalSwap(other);
0138     } else {
0139       ::google::protobuf::internal::GenericSwap(this, other);
0140     }
0141   }
0142   void UnsafeArenaSwap(OperatorProto* other) {
0143     if (other == this) return;
0144     ABSL_DCHECK(GetArena() == other->GetArena());
0145     InternalSwap(other);
0146   }
0147 
0148   // implements Message ----------------------------------------------
0149 
0150   OperatorProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0151     return ::google::protobuf::Message::DefaultConstruct<OperatorProto>(arena);
0152   }
0153   using ::google::protobuf::Message::CopyFrom;
0154   void CopyFrom(const OperatorProto& from);
0155   using ::google::protobuf::Message::MergeFrom;
0156   void MergeFrom(const OperatorProto& from) { OperatorProto::MergeImpl(*this, from); }
0157 
0158   private:
0159   static void MergeImpl(
0160       ::google::protobuf::MessageLite& to_msg,
0161       const ::google::protobuf::MessageLite& from_msg);
0162 
0163   public:
0164   bool IsInitialized() const {
0165     return true;
0166   }
0167   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0168   #if defined(PROTOBUF_CUSTOM_VTABLE)
0169   private:
0170   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0171   static ::uint8_t* _InternalSerialize(
0172       const MessageLite& msg, ::uint8_t* target,
0173       ::google::protobuf::io::EpsCopyOutputStream* stream);
0174 
0175   public:
0176   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0177   ::uint8_t* _InternalSerialize(
0178       ::uint8_t* target,
0179       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0180     return _InternalSerialize(*this, target, stream);
0181   }
0182   #else   // PROTOBUF_CUSTOM_VTABLE
0183   ::size_t ByteSizeLong() const final;
0184   ::uint8_t* _InternalSerialize(
0185       ::uint8_t* target,
0186       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0187   #endif  // PROTOBUF_CUSTOM_VTABLE
0188   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0189 
0190   private:
0191   void SharedCtor(::google::protobuf::Arena* arena);
0192   void SharedDtor();
0193   void InternalSwap(OperatorProto* other);
0194  private:
0195   friend class ::google::protobuf::internal::AnyMetadata;
0196   static ::absl::string_view FullMessageName() { return "onnx.OperatorProto"; }
0197 
0198  protected:
0199   explicit OperatorProto(::google::protobuf::Arena* arena);
0200   OperatorProto(::google::protobuf::Arena* arena, const OperatorProto& from);
0201   OperatorProto(::google::protobuf::Arena* arena, OperatorProto&& from) noexcept
0202       : OperatorProto(arena) {
0203     *this = ::std::move(from);
0204   }
0205   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0206   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0207 
0208  public:
0209   ::google::protobuf::Metadata GetMetadata() const;
0210   // nested types ----------------------------------------------------
0211 
0212   // accessors -------------------------------------------------------
0213   enum : int {
0214     kOpTypeFieldNumber = 1,
0215     kDocStringFieldNumber = 10,
0216     kSinceVersionFieldNumber = 2,
0217     kStatusFieldNumber = 3,
0218   };
0219   // optional string op_type = 1;
0220   bool has_op_type() const;
0221   void clear_op_type() ;
0222   const std::string& op_type() const;
0223   template <typename Arg_ = const std::string&, typename... Args_>
0224   void set_op_type(Arg_&& arg, Args_... args);
0225   std::string* mutable_op_type();
0226   PROTOBUF_NODISCARD std::string* release_op_type();
0227   void set_allocated_op_type(std::string* value);
0228 
0229   private:
0230   const std::string& _internal_op_type() const;
0231   inline PROTOBUF_ALWAYS_INLINE void _internal_set_op_type(
0232       const std::string& value);
0233   std::string* _internal_mutable_op_type();
0234 
0235   public:
0236   // optional string doc_string = 10;
0237   bool has_doc_string() const;
0238   void clear_doc_string() ;
0239   const std::string& doc_string() const;
0240   template <typename Arg_ = const std::string&, typename... Args_>
0241   void set_doc_string(Arg_&& arg, Args_... args);
0242   std::string* mutable_doc_string();
0243   PROTOBUF_NODISCARD std::string* release_doc_string();
0244   void set_allocated_doc_string(std::string* value);
0245 
0246   private:
0247   const std::string& _internal_doc_string() const;
0248   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
0249       const std::string& value);
0250   std::string* _internal_mutable_doc_string();
0251 
0252   public:
0253   // optional int64 since_version = 2;
0254   bool has_since_version() const;
0255   void clear_since_version() ;
0256   ::int64_t since_version() const;
0257   void set_since_version(::int64_t value);
0258 
0259   private:
0260   ::int64_t _internal_since_version() const;
0261   void _internal_set_since_version(::int64_t value);
0262 
0263   public:
0264   // optional .onnx.OperatorStatus status = 3;
0265   bool has_status() const;
0266   void clear_status() ;
0267   ::onnx::OperatorStatus status() const;
0268   void set_status(::onnx::OperatorStatus value);
0269 
0270   private:
0271   ::onnx::OperatorStatus _internal_status() const;
0272   void _internal_set_status(::onnx::OperatorStatus value);
0273 
0274   public:
0275   // @@protoc_insertion_point(class_scope:onnx.OperatorProto)
0276  private:
0277   class _Internal;
0278   friend class ::google::protobuf::internal::TcParser;
0279   static const ::google::protobuf::internal::TcParseTable<
0280       2, 4, 1,
0281       44, 2>
0282       _table_;
0283 
0284 
0285   friend class ::google::protobuf::MessageLite;
0286   friend class ::google::protobuf::Arena;
0287   template <typename T>
0288   friend class ::google::protobuf::Arena::InternalHelper;
0289   using InternalArenaConstructable_ = void;
0290   using DestructorSkippable_ = void;
0291   struct Impl_ {
0292     inline explicit constexpr Impl_(
0293         ::google::protobuf::internal::ConstantInitialized) noexcept;
0294     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0295                           ::google::protobuf::Arena* arena);
0296     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0297                           ::google::protobuf::Arena* arena, const Impl_& from,
0298                           const OperatorProto& from_msg);
0299     ::google::protobuf::internal::HasBits<1> _has_bits_;
0300     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0301     ::google::protobuf::internal::ArenaStringPtr op_type_;
0302     ::google::protobuf::internal::ArenaStringPtr doc_string_;
0303     ::int64_t since_version_;
0304     int status_;
0305     PROTOBUF_TSAN_DECLARE_MEMBER
0306   };
0307   union { Impl_ _impl_; };
0308   friend struct ::TableStruct_onnx_2fonnx_2doperators_2dml_2eproto;
0309 };
0310 // -------------------------------------------------------------------
0311 
0312 class ONNX_API OperatorSetProto final : public ::google::protobuf::Message
0313 /* @@protoc_insertion_point(class_definition:onnx.OperatorSetProto) */ {
0314  public:
0315   inline OperatorSetProto() : OperatorSetProto(nullptr) {}
0316   ~OperatorSetProto() PROTOBUF_FINAL;
0317   template <typename = void>
0318   explicit PROTOBUF_CONSTEXPR OperatorSetProto(
0319       ::google::protobuf::internal::ConstantInitialized);
0320 
0321   inline OperatorSetProto(const OperatorSetProto& from) : OperatorSetProto(nullptr, from) {}
0322   inline OperatorSetProto(OperatorSetProto&& from) noexcept
0323       : OperatorSetProto(nullptr, std::move(from)) {}
0324   inline OperatorSetProto& operator=(const OperatorSetProto& from) {
0325     CopyFrom(from);
0326     return *this;
0327   }
0328   inline OperatorSetProto& operator=(OperatorSetProto&& from) noexcept {
0329     if (this == &from) return *this;
0330     if (GetArena() == from.GetArena()
0331 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
0332         && GetArena() != nullptr
0333 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
0334     ) {
0335       InternalSwap(&from);
0336     } else {
0337       CopyFrom(from);
0338     }
0339     return *this;
0340   }
0341 
0342   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
0343       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0344     return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
0345   }
0346   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields()
0347       ABSL_ATTRIBUTE_LIFETIME_BOUND {
0348     return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
0349   }
0350 
0351   static const ::google::protobuf::Descriptor* descriptor() {
0352     return GetDescriptor();
0353   }
0354   static const ::google::protobuf::Descriptor* GetDescriptor() {
0355     return default_instance().GetMetadata().descriptor;
0356   }
0357   static const ::google::protobuf::Reflection* GetReflection() {
0358     return default_instance().GetMetadata().reflection;
0359   }
0360   static const OperatorSetProto& default_instance() {
0361     return *internal_default_instance();
0362   }
0363   static inline const OperatorSetProto* internal_default_instance() {
0364     return reinterpret_cast<const OperatorSetProto*>(
0365         &_OperatorSetProto_default_instance_);
0366   }
0367   static constexpr int kIndexInFileMessages = 1;
0368   friend void swap(OperatorSetProto& a, OperatorSetProto& b) { a.Swap(&b); }
0369   inline void Swap(OperatorSetProto* other) {
0370     if (other == this) return;
0371 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
0372     if (GetArena() != nullptr && GetArena() == other->GetArena()) {
0373 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
0374     if (GetArena() == other->GetArena()) {
0375 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
0376       InternalSwap(other);
0377     } else {
0378       ::google::protobuf::internal::GenericSwap(this, other);
0379     }
0380   }
0381   void UnsafeArenaSwap(OperatorSetProto* other) {
0382     if (other == this) return;
0383     ABSL_DCHECK(GetArena() == other->GetArena());
0384     InternalSwap(other);
0385   }
0386 
0387   // implements Message ----------------------------------------------
0388 
0389   OperatorSetProto* New(::google::protobuf::Arena* arena = nullptr) const PROTOBUF_FINAL {
0390     return ::google::protobuf::Message::DefaultConstruct<OperatorSetProto>(arena);
0391   }
0392   using ::google::protobuf::Message::CopyFrom;
0393   void CopyFrom(const OperatorSetProto& from);
0394   using ::google::protobuf::Message::MergeFrom;
0395   void MergeFrom(const OperatorSetProto& from) { OperatorSetProto::MergeImpl(*this, from); }
0396 
0397   private:
0398   static void MergeImpl(
0399       ::google::protobuf::MessageLite& to_msg,
0400       const ::google::protobuf::MessageLite& from_msg);
0401 
0402   public:
0403   bool IsInitialized() const {
0404     return true;
0405   }
0406   ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
0407   #if defined(PROTOBUF_CUSTOM_VTABLE)
0408   private:
0409   static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
0410   static ::uint8_t* _InternalSerialize(
0411       const MessageLite& msg, ::uint8_t* target,
0412       ::google::protobuf::io::EpsCopyOutputStream* stream);
0413 
0414   public:
0415   ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
0416   ::uint8_t* _InternalSerialize(
0417       ::uint8_t* target,
0418       ::google::protobuf::io::EpsCopyOutputStream* stream) const {
0419     return _InternalSerialize(*this, target, stream);
0420   }
0421   #else   // PROTOBUF_CUSTOM_VTABLE
0422   ::size_t ByteSizeLong() const final;
0423   ::uint8_t* _InternalSerialize(
0424       ::uint8_t* target,
0425       ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
0426   #endif  // PROTOBUF_CUSTOM_VTABLE
0427   int GetCachedSize() const { return _impl_._cached_size_.Get(); }
0428 
0429   private:
0430   void SharedCtor(::google::protobuf::Arena* arena);
0431   void SharedDtor();
0432   void InternalSwap(OperatorSetProto* other);
0433  private:
0434   friend class ::google::protobuf::internal::AnyMetadata;
0435   static ::absl::string_view FullMessageName() { return "onnx.OperatorSetProto"; }
0436 
0437  protected:
0438   explicit OperatorSetProto(::google::protobuf::Arena* arena);
0439   OperatorSetProto(::google::protobuf::Arena* arena, const OperatorSetProto& from);
0440   OperatorSetProto(::google::protobuf::Arena* arena, OperatorSetProto&& from) noexcept
0441       : OperatorSetProto(arena) {
0442     *this = ::std::move(from);
0443   }
0444   const ::google::protobuf::Message::ClassData* GetClassData() const PROTOBUF_FINAL;
0445   static const ::google::protobuf::Message::ClassDataFull _class_data_;
0446 
0447  public:
0448   ::google::protobuf::Metadata GetMetadata() const;
0449   // nested types ----------------------------------------------------
0450 
0451   // accessors -------------------------------------------------------
0452   enum : int {
0453     kOperatorFieldNumber = 8,
0454     kFunctionsFieldNumber = 9,
0455     kMagicFieldNumber = 1,
0456     kIrVersionPrereleaseFieldNumber = 3,
0457     kDomainFieldNumber = 4,
0458     kDocStringFieldNumber = 6,
0459     kIrBuildMetadataFieldNumber = 7,
0460     kIrVersionFieldNumber = 2,
0461     kOpsetVersionFieldNumber = 5,
0462   };
0463   // repeated .onnx.OperatorProto operator = 8;
0464   int operator__size() const;
0465   private:
0466   int _internal_operator__size() const;
0467 
0468   public:
0469   void clear_operator_() ;
0470   ::onnx::OperatorProto* mutable_operator_(int index);
0471   ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>* mutable_operator_();
0472 
0473   private:
0474   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>& _internal_operator_() const;
0475   ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>* _internal_mutable_operator_();
0476   public:
0477   const ::onnx::OperatorProto& operator_(int index) const;
0478   ::onnx::OperatorProto* add_operator_();
0479   const ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>& operator_() const;
0480   // repeated .onnx.FunctionProto functions = 9;
0481   int functions_size() const;
0482   private:
0483   int _internal_functions_size() const;
0484 
0485   public:
0486   void clear_functions() ;
0487   ::onnx::FunctionProto* mutable_functions(int index);
0488   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* mutable_functions();
0489 
0490   private:
0491   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& _internal_functions() const;
0492   ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* _internal_mutable_functions();
0493   public:
0494   const ::onnx::FunctionProto& functions(int index) const;
0495   ::onnx::FunctionProto* add_functions();
0496   const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& functions() const;
0497   // optional string magic = 1;
0498   bool has_magic() const;
0499   void clear_magic() ;
0500   const std::string& magic() const;
0501   template <typename Arg_ = const std::string&, typename... Args_>
0502   void set_magic(Arg_&& arg, Args_... args);
0503   std::string* mutable_magic();
0504   PROTOBUF_NODISCARD std::string* release_magic();
0505   void set_allocated_magic(std::string* value);
0506 
0507   private:
0508   const std::string& _internal_magic() const;
0509   inline PROTOBUF_ALWAYS_INLINE void _internal_set_magic(
0510       const std::string& value);
0511   std::string* _internal_mutable_magic();
0512 
0513   public:
0514   // optional string ir_version_prerelease = 3;
0515   bool has_ir_version_prerelease() const;
0516   void clear_ir_version_prerelease() ;
0517   const std::string& ir_version_prerelease() const;
0518   template <typename Arg_ = const std::string&, typename... Args_>
0519   void set_ir_version_prerelease(Arg_&& arg, Args_... args);
0520   std::string* mutable_ir_version_prerelease();
0521   PROTOBUF_NODISCARD std::string* release_ir_version_prerelease();
0522   void set_allocated_ir_version_prerelease(std::string* value);
0523 
0524   private:
0525   const std::string& _internal_ir_version_prerelease() const;
0526   inline PROTOBUF_ALWAYS_INLINE void _internal_set_ir_version_prerelease(
0527       const std::string& value);
0528   std::string* _internal_mutable_ir_version_prerelease();
0529 
0530   public:
0531   // optional string domain = 4;
0532   bool has_domain() const;
0533   void clear_domain() ;
0534   const std::string& domain() const;
0535   template <typename Arg_ = const std::string&, typename... Args_>
0536   void set_domain(Arg_&& arg, Args_... args);
0537   std::string* mutable_domain();
0538   PROTOBUF_NODISCARD std::string* release_domain();
0539   void set_allocated_domain(std::string* value);
0540 
0541   private:
0542   const std::string& _internal_domain() const;
0543   inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(
0544       const std::string& value);
0545   std::string* _internal_mutable_domain();
0546 
0547   public:
0548   // optional string doc_string = 6;
0549   bool has_doc_string() const;
0550   void clear_doc_string() ;
0551   const std::string& doc_string() const;
0552   template <typename Arg_ = const std::string&, typename... Args_>
0553   void set_doc_string(Arg_&& arg, Args_... args);
0554   std::string* mutable_doc_string();
0555   PROTOBUF_NODISCARD std::string* release_doc_string();
0556   void set_allocated_doc_string(std::string* value);
0557 
0558   private:
0559   const std::string& _internal_doc_string() const;
0560   inline PROTOBUF_ALWAYS_INLINE void _internal_set_doc_string(
0561       const std::string& value);
0562   std::string* _internal_mutable_doc_string();
0563 
0564   public:
0565   // optional string ir_build_metadata = 7;
0566   bool has_ir_build_metadata() const;
0567   void clear_ir_build_metadata() ;
0568   const std::string& ir_build_metadata() const;
0569   template <typename Arg_ = const std::string&, typename... Args_>
0570   void set_ir_build_metadata(Arg_&& arg, Args_... args);
0571   std::string* mutable_ir_build_metadata();
0572   PROTOBUF_NODISCARD std::string* release_ir_build_metadata();
0573   void set_allocated_ir_build_metadata(std::string* value);
0574 
0575   private:
0576   const std::string& _internal_ir_build_metadata() const;
0577   inline PROTOBUF_ALWAYS_INLINE void _internal_set_ir_build_metadata(
0578       const std::string& value);
0579   std::string* _internal_mutable_ir_build_metadata();
0580 
0581   public:
0582   // optional int64 ir_version = 2;
0583   bool has_ir_version() const;
0584   void clear_ir_version() ;
0585   ::int64_t ir_version() const;
0586   void set_ir_version(::int64_t value);
0587 
0588   private:
0589   ::int64_t _internal_ir_version() const;
0590   void _internal_set_ir_version(::int64_t value);
0591 
0592   public:
0593   // optional int64 opset_version = 5;
0594   bool has_opset_version() const;
0595   void clear_opset_version() ;
0596   ::int64_t opset_version() const;
0597   void set_opset_version(::int64_t value);
0598 
0599   private:
0600   ::int64_t _internal_opset_version() const;
0601   void _internal_set_opset_version(::int64_t value);
0602 
0603   public:
0604   // @@protoc_insertion_point(class_scope:onnx.OperatorSetProto)
0605  private:
0606   class _Internal;
0607   friend class ::google::protobuf::internal::TcParser;
0608   static const ::google::protobuf::internal::TcParseTable<
0609       4, 9, 2,
0610       97, 2>
0611       _table_;
0612 
0613 
0614   friend class ::google::protobuf::MessageLite;
0615   friend class ::google::protobuf::Arena;
0616   template <typename T>
0617   friend class ::google::protobuf::Arena::InternalHelper;
0618   using InternalArenaConstructable_ = void;
0619   using DestructorSkippable_ = void;
0620   struct Impl_ {
0621     inline explicit constexpr Impl_(
0622         ::google::protobuf::internal::ConstantInitialized) noexcept;
0623     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0624                           ::google::protobuf::Arena* arena);
0625     inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
0626                           ::google::protobuf::Arena* arena, const Impl_& from,
0627                           const OperatorSetProto& from_msg);
0628     ::google::protobuf::internal::HasBits<1> _has_bits_;
0629     mutable ::google::protobuf::internal::CachedSize _cached_size_;
0630     ::google::protobuf::RepeatedPtrField< ::onnx::OperatorProto > operator__;
0631     ::google::protobuf::RepeatedPtrField< ::onnx::FunctionProto > functions_;
0632     ::google::protobuf::internal::ArenaStringPtr magic_;
0633     ::google::protobuf::internal::ArenaStringPtr ir_version_prerelease_;
0634     ::google::protobuf::internal::ArenaStringPtr domain_;
0635     ::google::protobuf::internal::ArenaStringPtr doc_string_;
0636     ::google::protobuf::internal::ArenaStringPtr ir_build_metadata_;
0637     ::int64_t ir_version_;
0638     ::int64_t opset_version_;
0639     PROTOBUF_TSAN_DECLARE_MEMBER
0640   };
0641   union { Impl_ _impl_; };
0642   friend struct ::TableStruct_onnx_2fonnx_2doperators_2dml_2eproto;
0643 };
0644 
0645 // ===================================================================
0646 
0647 
0648 
0649 
0650 // ===================================================================
0651 
0652 
0653 #ifdef __GNUC__
0654 #pragma GCC diagnostic push
0655 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
0656 #endif  // __GNUC__
0657 // -------------------------------------------------------------------
0658 
0659 // OperatorProto
0660 
0661 // optional string op_type = 1;
0662 inline bool OperatorProto::has_op_type() const {
0663   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
0664   return value;
0665 }
0666 inline void OperatorProto::clear_op_type() {
0667   ::google::protobuf::internal::TSanWrite(&_impl_);
0668   _impl_.op_type_.ClearToEmpty();
0669   _impl_._has_bits_[0] &= ~0x00000001u;
0670 }
0671 inline const std::string& OperatorProto::op_type() const
0672     ABSL_ATTRIBUTE_LIFETIME_BOUND {
0673   // @@protoc_insertion_point(field_get:onnx.OperatorProto.op_type)
0674   return _internal_op_type();
0675 }
0676 template <typename Arg_, typename... Args_>
0677 inline PROTOBUF_ALWAYS_INLINE void OperatorProto::set_op_type(Arg_&& arg,
0678                                                      Args_... args) {
0679   ::google::protobuf::internal::TSanWrite(&_impl_);
0680   _impl_._has_bits_[0] |= 0x00000001u;
0681   _impl_.op_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
0682   // @@protoc_insertion_point(field_set:onnx.OperatorProto.op_type)
0683 }
0684 inline std::string* OperatorProto::mutable_op_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
0685   std::string* _s = _internal_mutable_op_type();
0686   // @@protoc_insertion_point(field_mutable:onnx.OperatorProto.op_type)
0687   return _s;
0688 }
0689 inline const std::string& OperatorProto::_internal_op_type() const {
0690   ::google::protobuf::internal::TSanRead(&_impl_);
0691   return _impl_.op_type_.Get();
0692 }
0693 inline void OperatorProto::_internal_set_op_type(const std::string& value) {
0694   ::google::protobuf::internal::TSanWrite(&_impl_);
0695   _impl_._has_bits_[0] |= 0x00000001u;
0696   _impl_.op_type_.Set(value, GetArena());
0697 }
0698 inline std::string* OperatorProto::_internal_mutable_op_type() {
0699   ::google::protobuf::internal::TSanWrite(&_impl_);
0700   _impl_._has_bits_[0] |= 0x00000001u;
0701   return _impl_.op_type_.Mutable( GetArena());
0702 }
0703 inline std::string* OperatorProto::release_op_type() {
0704   ::google::protobuf::internal::TSanWrite(&_impl_);
0705   // @@protoc_insertion_point(field_release:onnx.OperatorProto.op_type)
0706   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
0707     return nullptr;
0708   }
0709   _impl_._has_bits_[0] &= ~0x00000001u;
0710   auto* released = _impl_.op_type_.Release();
0711   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0712   _impl_.op_type_.Set("", GetArena());
0713   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0714   return released;
0715 }
0716 inline void OperatorProto::set_allocated_op_type(std::string* value) {
0717   ::google::protobuf::internal::TSanWrite(&_impl_);
0718   if (value != nullptr) {
0719     _impl_._has_bits_[0] |= 0x00000001u;
0720   } else {
0721     _impl_._has_bits_[0] &= ~0x00000001u;
0722   }
0723   _impl_.op_type_.SetAllocated(value, GetArena());
0724   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0725         if (_impl_.op_type_.IsDefault()) {
0726           _impl_.op_type_.Set("", GetArena());
0727         }
0728   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0729   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorProto.op_type)
0730 }
0731 
0732 // optional int64 since_version = 2;
0733 inline bool OperatorProto::has_since_version() const {
0734   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
0735   return value;
0736 }
0737 inline void OperatorProto::clear_since_version() {
0738   ::google::protobuf::internal::TSanWrite(&_impl_);
0739   _impl_.since_version_ = ::int64_t{0};
0740   _impl_._has_bits_[0] &= ~0x00000004u;
0741 }
0742 inline ::int64_t OperatorProto::since_version() const {
0743   // @@protoc_insertion_point(field_get:onnx.OperatorProto.since_version)
0744   return _internal_since_version();
0745 }
0746 inline void OperatorProto::set_since_version(::int64_t value) {
0747   _internal_set_since_version(value);
0748   _impl_._has_bits_[0] |= 0x00000004u;
0749   // @@protoc_insertion_point(field_set:onnx.OperatorProto.since_version)
0750 }
0751 inline ::int64_t OperatorProto::_internal_since_version() const {
0752   ::google::protobuf::internal::TSanRead(&_impl_);
0753   return _impl_.since_version_;
0754 }
0755 inline void OperatorProto::_internal_set_since_version(::int64_t value) {
0756   ::google::protobuf::internal::TSanWrite(&_impl_);
0757   _impl_.since_version_ = value;
0758 }
0759 
0760 // optional .onnx.OperatorStatus status = 3;
0761 inline bool OperatorProto::has_status() const {
0762   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
0763   return value;
0764 }
0765 inline void OperatorProto::clear_status() {
0766   ::google::protobuf::internal::TSanWrite(&_impl_);
0767   _impl_.status_ = 0;
0768   _impl_._has_bits_[0] &= ~0x00000008u;
0769 }
0770 inline ::onnx::OperatorStatus OperatorProto::status() const {
0771   // @@protoc_insertion_point(field_get:onnx.OperatorProto.status)
0772   return _internal_status();
0773 }
0774 inline void OperatorProto::set_status(::onnx::OperatorStatus value) {
0775   _internal_set_status(value);
0776   _impl_._has_bits_[0] |= 0x00000008u;
0777   // @@protoc_insertion_point(field_set:onnx.OperatorProto.status)
0778 }
0779 inline ::onnx::OperatorStatus OperatorProto::_internal_status() const {
0780   ::google::protobuf::internal::TSanRead(&_impl_);
0781   return static_cast<::onnx::OperatorStatus>(_impl_.status_);
0782 }
0783 inline void OperatorProto::_internal_set_status(::onnx::OperatorStatus value) {
0784   ::google::protobuf::internal::TSanWrite(&_impl_);
0785   assert(::onnx::OperatorStatus_IsValid(value));
0786   _impl_.status_ = value;
0787 }
0788 
0789 // optional string doc_string = 10;
0790 inline bool OperatorProto::has_doc_string() const {
0791   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
0792   return value;
0793 }
0794 inline void OperatorProto::clear_doc_string() {
0795   ::google::protobuf::internal::TSanWrite(&_impl_);
0796   _impl_.doc_string_.ClearToEmpty();
0797   _impl_._has_bits_[0] &= ~0x00000002u;
0798 }
0799 inline const std::string& OperatorProto::doc_string() const
0800     ABSL_ATTRIBUTE_LIFETIME_BOUND {
0801   // @@protoc_insertion_point(field_get:onnx.OperatorProto.doc_string)
0802   return _internal_doc_string();
0803 }
0804 template <typename Arg_, typename... Args_>
0805 inline PROTOBUF_ALWAYS_INLINE void OperatorProto::set_doc_string(Arg_&& arg,
0806                                                      Args_... args) {
0807   ::google::protobuf::internal::TSanWrite(&_impl_);
0808   _impl_._has_bits_[0] |= 0x00000002u;
0809   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
0810   // @@protoc_insertion_point(field_set:onnx.OperatorProto.doc_string)
0811 }
0812 inline std::string* OperatorProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
0813   std::string* _s = _internal_mutable_doc_string();
0814   // @@protoc_insertion_point(field_mutable:onnx.OperatorProto.doc_string)
0815   return _s;
0816 }
0817 inline const std::string& OperatorProto::_internal_doc_string() const {
0818   ::google::protobuf::internal::TSanRead(&_impl_);
0819   return _impl_.doc_string_.Get();
0820 }
0821 inline void OperatorProto::_internal_set_doc_string(const std::string& value) {
0822   ::google::protobuf::internal::TSanWrite(&_impl_);
0823   _impl_._has_bits_[0] |= 0x00000002u;
0824   _impl_.doc_string_.Set(value, GetArena());
0825 }
0826 inline std::string* OperatorProto::_internal_mutable_doc_string() {
0827   ::google::protobuf::internal::TSanWrite(&_impl_);
0828   _impl_._has_bits_[0] |= 0x00000002u;
0829   return _impl_.doc_string_.Mutable( GetArena());
0830 }
0831 inline std::string* OperatorProto::release_doc_string() {
0832   ::google::protobuf::internal::TSanWrite(&_impl_);
0833   // @@protoc_insertion_point(field_release:onnx.OperatorProto.doc_string)
0834   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
0835     return nullptr;
0836   }
0837   _impl_._has_bits_[0] &= ~0x00000002u;
0838   auto* released = _impl_.doc_string_.Release();
0839   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0840   _impl_.doc_string_.Set("", GetArena());
0841   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0842   return released;
0843 }
0844 inline void OperatorProto::set_allocated_doc_string(std::string* value) {
0845   ::google::protobuf::internal::TSanWrite(&_impl_);
0846   if (value != nullptr) {
0847     _impl_._has_bits_[0] |= 0x00000002u;
0848   } else {
0849     _impl_._has_bits_[0] &= ~0x00000002u;
0850   }
0851   _impl_.doc_string_.SetAllocated(value, GetArena());
0852   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0853         if (_impl_.doc_string_.IsDefault()) {
0854           _impl_.doc_string_.Set("", GetArena());
0855         }
0856   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0857   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorProto.doc_string)
0858 }
0859 
0860 // -------------------------------------------------------------------
0861 
0862 // OperatorSetProto
0863 
0864 // optional string magic = 1;
0865 inline bool OperatorSetProto::has_magic() const {
0866   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
0867   return value;
0868 }
0869 inline void OperatorSetProto::clear_magic() {
0870   ::google::protobuf::internal::TSanWrite(&_impl_);
0871   _impl_.magic_.ClearToEmpty();
0872   _impl_._has_bits_[0] &= ~0x00000001u;
0873 }
0874 inline const std::string& OperatorSetProto::magic() const
0875     ABSL_ATTRIBUTE_LIFETIME_BOUND {
0876   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.magic)
0877   return _internal_magic();
0878 }
0879 template <typename Arg_, typename... Args_>
0880 inline PROTOBUF_ALWAYS_INLINE void OperatorSetProto::set_magic(Arg_&& arg,
0881                                                      Args_... args) {
0882   ::google::protobuf::internal::TSanWrite(&_impl_);
0883   _impl_._has_bits_[0] |= 0x00000001u;
0884   _impl_.magic_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
0885   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.magic)
0886 }
0887 inline std::string* OperatorSetProto::mutable_magic() ABSL_ATTRIBUTE_LIFETIME_BOUND {
0888   std::string* _s = _internal_mutable_magic();
0889   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.magic)
0890   return _s;
0891 }
0892 inline const std::string& OperatorSetProto::_internal_magic() const {
0893   ::google::protobuf::internal::TSanRead(&_impl_);
0894   return _impl_.magic_.Get();
0895 }
0896 inline void OperatorSetProto::_internal_set_magic(const std::string& value) {
0897   ::google::protobuf::internal::TSanWrite(&_impl_);
0898   _impl_._has_bits_[0] |= 0x00000001u;
0899   _impl_.magic_.Set(value, GetArena());
0900 }
0901 inline std::string* OperatorSetProto::_internal_mutable_magic() {
0902   ::google::protobuf::internal::TSanWrite(&_impl_);
0903   _impl_._has_bits_[0] |= 0x00000001u;
0904   return _impl_.magic_.Mutable( GetArena());
0905 }
0906 inline std::string* OperatorSetProto::release_magic() {
0907   ::google::protobuf::internal::TSanWrite(&_impl_);
0908   // @@protoc_insertion_point(field_release:onnx.OperatorSetProto.magic)
0909   if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
0910     return nullptr;
0911   }
0912   _impl_._has_bits_[0] &= ~0x00000001u;
0913   auto* released = _impl_.magic_.Release();
0914   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0915   _impl_.magic_.Set("", GetArena());
0916   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0917   return released;
0918 }
0919 inline void OperatorSetProto::set_allocated_magic(std::string* value) {
0920   ::google::protobuf::internal::TSanWrite(&_impl_);
0921   if (value != nullptr) {
0922     _impl_._has_bits_[0] |= 0x00000001u;
0923   } else {
0924     _impl_._has_bits_[0] &= ~0x00000001u;
0925   }
0926   _impl_.magic_.SetAllocated(value, GetArena());
0927   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
0928         if (_impl_.magic_.IsDefault()) {
0929           _impl_.magic_.Set("", GetArena());
0930         }
0931   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
0932   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetProto.magic)
0933 }
0934 
0935 // optional int64 ir_version = 2;
0936 inline bool OperatorSetProto::has_ir_version() const {
0937   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
0938   return value;
0939 }
0940 inline void OperatorSetProto::clear_ir_version() {
0941   ::google::protobuf::internal::TSanWrite(&_impl_);
0942   _impl_.ir_version_ = ::int64_t{0};
0943   _impl_._has_bits_[0] &= ~0x00000020u;
0944 }
0945 inline ::int64_t OperatorSetProto::ir_version() const {
0946   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.ir_version)
0947   return _internal_ir_version();
0948 }
0949 inline void OperatorSetProto::set_ir_version(::int64_t value) {
0950   _internal_set_ir_version(value);
0951   _impl_._has_bits_[0] |= 0x00000020u;
0952   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.ir_version)
0953 }
0954 inline ::int64_t OperatorSetProto::_internal_ir_version() const {
0955   ::google::protobuf::internal::TSanRead(&_impl_);
0956   return _impl_.ir_version_;
0957 }
0958 inline void OperatorSetProto::_internal_set_ir_version(::int64_t value) {
0959   ::google::protobuf::internal::TSanWrite(&_impl_);
0960   _impl_.ir_version_ = value;
0961 }
0962 
0963 // optional string ir_version_prerelease = 3;
0964 inline bool OperatorSetProto::has_ir_version_prerelease() const {
0965   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
0966   return value;
0967 }
0968 inline void OperatorSetProto::clear_ir_version_prerelease() {
0969   ::google::protobuf::internal::TSanWrite(&_impl_);
0970   _impl_.ir_version_prerelease_.ClearToEmpty();
0971   _impl_._has_bits_[0] &= ~0x00000002u;
0972 }
0973 inline const std::string& OperatorSetProto::ir_version_prerelease() const
0974     ABSL_ATTRIBUTE_LIFETIME_BOUND {
0975   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.ir_version_prerelease)
0976   return _internal_ir_version_prerelease();
0977 }
0978 template <typename Arg_, typename... Args_>
0979 inline PROTOBUF_ALWAYS_INLINE void OperatorSetProto::set_ir_version_prerelease(Arg_&& arg,
0980                                                      Args_... args) {
0981   ::google::protobuf::internal::TSanWrite(&_impl_);
0982   _impl_._has_bits_[0] |= 0x00000002u;
0983   _impl_.ir_version_prerelease_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
0984   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.ir_version_prerelease)
0985 }
0986 inline std::string* OperatorSetProto::mutable_ir_version_prerelease() ABSL_ATTRIBUTE_LIFETIME_BOUND {
0987   std::string* _s = _internal_mutable_ir_version_prerelease();
0988   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.ir_version_prerelease)
0989   return _s;
0990 }
0991 inline const std::string& OperatorSetProto::_internal_ir_version_prerelease() const {
0992   ::google::protobuf::internal::TSanRead(&_impl_);
0993   return _impl_.ir_version_prerelease_.Get();
0994 }
0995 inline void OperatorSetProto::_internal_set_ir_version_prerelease(const std::string& value) {
0996   ::google::protobuf::internal::TSanWrite(&_impl_);
0997   _impl_._has_bits_[0] |= 0x00000002u;
0998   _impl_.ir_version_prerelease_.Set(value, GetArena());
0999 }
1000 inline std::string* OperatorSetProto::_internal_mutable_ir_version_prerelease() {
1001   ::google::protobuf::internal::TSanWrite(&_impl_);
1002   _impl_._has_bits_[0] |= 0x00000002u;
1003   return _impl_.ir_version_prerelease_.Mutable( GetArena());
1004 }
1005 inline std::string* OperatorSetProto::release_ir_version_prerelease() {
1006   ::google::protobuf::internal::TSanWrite(&_impl_);
1007   // @@protoc_insertion_point(field_release:onnx.OperatorSetProto.ir_version_prerelease)
1008   if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
1009     return nullptr;
1010   }
1011   _impl_._has_bits_[0] &= ~0x00000002u;
1012   auto* released = _impl_.ir_version_prerelease_.Release();
1013   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1014   _impl_.ir_version_prerelease_.Set("", GetArena());
1015   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1016   return released;
1017 }
1018 inline void OperatorSetProto::set_allocated_ir_version_prerelease(std::string* value) {
1019   ::google::protobuf::internal::TSanWrite(&_impl_);
1020   if (value != nullptr) {
1021     _impl_._has_bits_[0] |= 0x00000002u;
1022   } else {
1023     _impl_._has_bits_[0] &= ~0x00000002u;
1024   }
1025   _impl_.ir_version_prerelease_.SetAllocated(value, GetArena());
1026   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1027         if (_impl_.ir_version_prerelease_.IsDefault()) {
1028           _impl_.ir_version_prerelease_.Set("", GetArena());
1029         }
1030   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1031   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetProto.ir_version_prerelease)
1032 }
1033 
1034 // optional string ir_build_metadata = 7;
1035 inline bool OperatorSetProto::has_ir_build_metadata() const {
1036   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
1037   return value;
1038 }
1039 inline void OperatorSetProto::clear_ir_build_metadata() {
1040   ::google::protobuf::internal::TSanWrite(&_impl_);
1041   _impl_.ir_build_metadata_.ClearToEmpty();
1042   _impl_._has_bits_[0] &= ~0x00000010u;
1043 }
1044 inline const std::string& OperatorSetProto::ir_build_metadata() const
1045     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1046   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.ir_build_metadata)
1047   return _internal_ir_build_metadata();
1048 }
1049 template <typename Arg_, typename... Args_>
1050 inline PROTOBUF_ALWAYS_INLINE void OperatorSetProto::set_ir_build_metadata(Arg_&& arg,
1051                                                      Args_... args) {
1052   ::google::protobuf::internal::TSanWrite(&_impl_);
1053   _impl_._has_bits_[0] |= 0x00000010u;
1054   _impl_.ir_build_metadata_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1055   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.ir_build_metadata)
1056 }
1057 inline std::string* OperatorSetProto::mutable_ir_build_metadata() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1058   std::string* _s = _internal_mutable_ir_build_metadata();
1059   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.ir_build_metadata)
1060   return _s;
1061 }
1062 inline const std::string& OperatorSetProto::_internal_ir_build_metadata() const {
1063   ::google::protobuf::internal::TSanRead(&_impl_);
1064   return _impl_.ir_build_metadata_.Get();
1065 }
1066 inline void OperatorSetProto::_internal_set_ir_build_metadata(const std::string& value) {
1067   ::google::protobuf::internal::TSanWrite(&_impl_);
1068   _impl_._has_bits_[0] |= 0x00000010u;
1069   _impl_.ir_build_metadata_.Set(value, GetArena());
1070 }
1071 inline std::string* OperatorSetProto::_internal_mutable_ir_build_metadata() {
1072   ::google::protobuf::internal::TSanWrite(&_impl_);
1073   _impl_._has_bits_[0] |= 0x00000010u;
1074   return _impl_.ir_build_metadata_.Mutable( GetArena());
1075 }
1076 inline std::string* OperatorSetProto::release_ir_build_metadata() {
1077   ::google::protobuf::internal::TSanWrite(&_impl_);
1078   // @@protoc_insertion_point(field_release:onnx.OperatorSetProto.ir_build_metadata)
1079   if ((_impl_._has_bits_[0] & 0x00000010u) == 0) {
1080     return nullptr;
1081   }
1082   _impl_._has_bits_[0] &= ~0x00000010u;
1083   auto* released = _impl_.ir_build_metadata_.Release();
1084   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1085   _impl_.ir_build_metadata_.Set("", GetArena());
1086   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1087   return released;
1088 }
1089 inline void OperatorSetProto::set_allocated_ir_build_metadata(std::string* value) {
1090   ::google::protobuf::internal::TSanWrite(&_impl_);
1091   if (value != nullptr) {
1092     _impl_._has_bits_[0] |= 0x00000010u;
1093   } else {
1094     _impl_._has_bits_[0] &= ~0x00000010u;
1095   }
1096   _impl_.ir_build_metadata_.SetAllocated(value, GetArena());
1097   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1098         if (_impl_.ir_build_metadata_.IsDefault()) {
1099           _impl_.ir_build_metadata_.Set("", GetArena());
1100         }
1101   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1102   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetProto.ir_build_metadata)
1103 }
1104 
1105 // optional string domain = 4;
1106 inline bool OperatorSetProto::has_domain() const {
1107   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1108   return value;
1109 }
1110 inline void OperatorSetProto::clear_domain() {
1111   ::google::protobuf::internal::TSanWrite(&_impl_);
1112   _impl_.domain_.ClearToEmpty();
1113   _impl_._has_bits_[0] &= ~0x00000004u;
1114 }
1115 inline const std::string& OperatorSetProto::domain() const
1116     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1117   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.domain)
1118   return _internal_domain();
1119 }
1120 template <typename Arg_, typename... Args_>
1121 inline PROTOBUF_ALWAYS_INLINE void OperatorSetProto::set_domain(Arg_&& arg,
1122                                                      Args_... args) {
1123   ::google::protobuf::internal::TSanWrite(&_impl_);
1124   _impl_._has_bits_[0] |= 0x00000004u;
1125   _impl_.domain_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1126   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.domain)
1127 }
1128 inline std::string* OperatorSetProto::mutable_domain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1129   std::string* _s = _internal_mutable_domain();
1130   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.domain)
1131   return _s;
1132 }
1133 inline const std::string& OperatorSetProto::_internal_domain() const {
1134   ::google::protobuf::internal::TSanRead(&_impl_);
1135   return _impl_.domain_.Get();
1136 }
1137 inline void OperatorSetProto::_internal_set_domain(const std::string& value) {
1138   ::google::protobuf::internal::TSanWrite(&_impl_);
1139   _impl_._has_bits_[0] |= 0x00000004u;
1140   _impl_.domain_.Set(value, GetArena());
1141 }
1142 inline std::string* OperatorSetProto::_internal_mutable_domain() {
1143   ::google::protobuf::internal::TSanWrite(&_impl_);
1144   _impl_._has_bits_[0] |= 0x00000004u;
1145   return _impl_.domain_.Mutable( GetArena());
1146 }
1147 inline std::string* OperatorSetProto::release_domain() {
1148   ::google::protobuf::internal::TSanWrite(&_impl_);
1149   // @@protoc_insertion_point(field_release:onnx.OperatorSetProto.domain)
1150   if ((_impl_._has_bits_[0] & 0x00000004u) == 0) {
1151     return nullptr;
1152   }
1153   _impl_._has_bits_[0] &= ~0x00000004u;
1154   auto* released = _impl_.domain_.Release();
1155   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1156   _impl_.domain_.Set("", GetArena());
1157   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1158   return released;
1159 }
1160 inline void OperatorSetProto::set_allocated_domain(std::string* value) {
1161   ::google::protobuf::internal::TSanWrite(&_impl_);
1162   if (value != nullptr) {
1163     _impl_._has_bits_[0] |= 0x00000004u;
1164   } else {
1165     _impl_._has_bits_[0] &= ~0x00000004u;
1166   }
1167   _impl_.domain_.SetAllocated(value, GetArena());
1168   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1169         if (_impl_.domain_.IsDefault()) {
1170           _impl_.domain_.Set("", GetArena());
1171         }
1172   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1173   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetProto.domain)
1174 }
1175 
1176 // optional int64 opset_version = 5;
1177 inline bool OperatorSetProto::has_opset_version() const {
1178   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
1179   return value;
1180 }
1181 inline void OperatorSetProto::clear_opset_version() {
1182   ::google::protobuf::internal::TSanWrite(&_impl_);
1183   _impl_.opset_version_ = ::int64_t{0};
1184   _impl_._has_bits_[0] &= ~0x00000040u;
1185 }
1186 inline ::int64_t OperatorSetProto::opset_version() const {
1187   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.opset_version)
1188   return _internal_opset_version();
1189 }
1190 inline void OperatorSetProto::set_opset_version(::int64_t value) {
1191   _internal_set_opset_version(value);
1192   _impl_._has_bits_[0] |= 0x00000040u;
1193   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.opset_version)
1194 }
1195 inline ::int64_t OperatorSetProto::_internal_opset_version() const {
1196   ::google::protobuf::internal::TSanRead(&_impl_);
1197   return _impl_.opset_version_;
1198 }
1199 inline void OperatorSetProto::_internal_set_opset_version(::int64_t value) {
1200   ::google::protobuf::internal::TSanWrite(&_impl_);
1201   _impl_.opset_version_ = value;
1202 }
1203 
1204 // optional string doc_string = 6;
1205 inline bool OperatorSetProto::has_doc_string() const {
1206   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1207   return value;
1208 }
1209 inline void OperatorSetProto::clear_doc_string() {
1210   ::google::protobuf::internal::TSanWrite(&_impl_);
1211   _impl_.doc_string_.ClearToEmpty();
1212   _impl_._has_bits_[0] &= ~0x00000008u;
1213 }
1214 inline const std::string& OperatorSetProto::doc_string() const
1215     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1216   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.doc_string)
1217   return _internal_doc_string();
1218 }
1219 template <typename Arg_, typename... Args_>
1220 inline PROTOBUF_ALWAYS_INLINE void OperatorSetProto::set_doc_string(Arg_&& arg,
1221                                                      Args_... args) {
1222   ::google::protobuf::internal::TSanWrite(&_impl_);
1223   _impl_._has_bits_[0] |= 0x00000008u;
1224   _impl_.doc_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
1225   // @@protoc_insertion_point(field_set:onnx.OperatorSetProto.doc_string)
1226 }
1227 inline std::string* OperatorSetProto::mutable_doc_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1228   std::string* _s = _internal_mutable_doc_string();
1229   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.doc_string)
1230   return _s;
1231 }
1232 inline const std::string& OperatorSetProto::_internal_doc_string() const {
1233   ::google::protobuf::internal::TSanRead(&_impl_);
1234   return _impl_.doc_string_.Get();
1235 }
1236 inline void OperatorSetProto::_internal_set_doc_string(const std::string& value) {
1237   ::google::protobuf::internal::TSanWrite(&_impl_);
1238   _impl_._has_bits_[0] |= 0x00000008u;
1239   _impl_.doc_string_.Set(value, GetArena());
1240 }
1241 inline std::string* OperatorSetProto::_internal_mutable_doc_string() {
1242   ::google::protobuf::internal::TSanWrite(&_impl_);
1243   _impl_._has_bits_[0] |= 0x00000008u;
1244   return _impl_.doc_string_.Mutable( GetArena());
1245 }
1246 inline std::string* OperatorSetProto::release_doc_string() {
1247   ::google::protobuf::internal::TSanWrite(&_impl_);
1248   // @@protoc_insertion_point(field_release:onnx.OperatorSetProto.doc_string)
1249   if ((_impl_._has_bits_[0] & 0x00000008u) == 0) {
1250     return nullptr;
1251   }
1252   _impl_._has_bits_[0] &= ~0x00000008u;
1253   auto* released = _impl_.doc_string_.Release();
1254   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1255   _impl_.doc_string_.Set("", GetArena());
1256   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1257   return released;
1258 }
1259 inline void OperatorSetProto::set_allocated_doc_string(std::string* value) {
1260   ::google::protobuf::internal::TSanWrite(&_impl_);
1261   if (value != nullptr) {
1262     _impl_._has_bits_[0] |= 0x00000008u;
1263   } else {
1264     _impl_._has_bits_[0] &= ~0x00000008u;
1265   }
1266   _impl_.doc_string_.SetAllocated(value, GetArena());
1267   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1268         if (_impl_.doc_string_.IsDefault()) {
1269           _impl_.doc_string_.Set("", GetArena());
1270         }
1271   #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1272   // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetProto.doc_string)
1273 }
1274 
1275 // repeated .onnx.OperatorProto operator = 8;
1276 inline int OperatorSetProto::_internal_operator__size() const {
1277   return _internal_operator_().size();
1278 }
1279 inline int OperatorSetProto::operator__size() const {
1280   return _internal_operator__size();
1281 }
1282 inline void OperatorSetProto::clear_operator_() {
1283   ::google::protobuf::internal::TSanWrite(&_impl_);
1284   _impl_.operator__.Clear();
1285 }
1286 inline ::onnx::OperatorProto* OperatorSetProto::mutable_operator_(int index)
1287     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1288   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.operator)
1289   return _internal_mutable_operator_()->Mutable(index);
1290 }
1291 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>* OperatorSetProto::mutable_operator_()
1292     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1293   // @@protoc_insertion_point(field_mutable_list:onnx.OperatorSetProto.operator)
1294   ::google::protobuf::internal::TSanWrite(&_impl_);
1295   return _internal_mutable_operator_();
1296 }
1297 inline const ::onnx::OperatorProto& OperatorSetProto::operator_(int index) const
1298     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1299   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.operator)
1300   return _internal_operator_().Get(index);
1301 }
1302 inline ::onnx::OperatorProto* OperatorSetProto::add_operator_() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1303   ::google::protobuf::internal::TSanWrite(&_impl_);
1304   ::onnx::OperatorProto* _add = _internal_mutable_operator_()->Add();
1305   // @@protoc_insertion_point(field_add:onnx.OperatorSetProto.operator)
1306   return _add;
1307 }
1308 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>& OperatorSetProto::operator_() const
1309     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1310   // @@protoc_insertion_point(field_list:onnx.OperatorSetProto.operator)
1311   return _internal_operator_();
1312 }
1313 inline const ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>&
1314 OperatorSetProto::_internal_operator_() const {
1315   ::google::protobuf::internal::TSanRead(&_impl_);
1316   return _impl_.operator__;
1317 }
1318 inline ::google::protobuf::RepeatedPtrField<::onnx::OperatorProto>*
1319 OperatorSetProto::_internal_mutable_operator_() {
1320   ::google::protobuf::internal::TSanRead(&_impl_);
1321   return &_impl_.operator__;
1322 }
1323 
1324 // repeated .onnx.FunctionProto functions = 9;
1325 inline int OperatorSetProto::_internal_functions_size() const {
1326   return _internal_functions().size();
1327 }
1328 inline int OperatorSetProto::functions_size() const {
1329   return _internal_functions_size();
1330 }
1331 inline ::onnx::FunctionProto* OperatorSetProto::mutable_functions(int index)
1332     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1333   // @@protoc_insertion_point(field_mutable:onnx.OperatorSetProto.functions)
1334   return _internal_mutable_functions()->Mutable(index);
1335 }
1336 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>* OperatorSetProto::mutable_functions()
1337     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1338   // @@protoc_insertion_point(field_mutable_list:onnx.OperatorSetProto.functions)
1339   ::google::protobuf::internal::TSanWrite(&_impl_);
1340   return _internal_mutable_functions();
1341 }
1342 inline const ::onnx::FunctionProto& OperatorSetProto::functions(int index) const
1343     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1344   // @@protoc_insertion_point(field_get:onnx.OperatorSetProto.functions)
1345   return _internal_functions().Get(index);
1346 }
1347 inline ::onnx::FunctionProto* OperatorSetProto::add_functions() ABSL_ATTRIBUTE_LIFETIME_BOUND {
1348   ::google::protobuf::internal::TSanWrite(&_impl_);
1349   ::onnx::FunctionProto* _add = _internal_mutable_functions()->Add();
1350   // @@protoc_insertion_point(field_add:onnx.OperatorSetProto.functions)
1351   return _add;
1352 }
1353 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>& OperatorSetProto::functions() const
1354     ABSL_ATTRIBUTE_LIFETIME_BOUND {
1355   // @@protoc_insertion_point(field_list:onnx.OperatorSetProto.functions)
1356   return _internal_functions();
1357 }
1358 inline const ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>&
1359 OperatorSetProto::_internal_functions() const {
1360   ::google::protobuf::internal::TSanRead(&_impl_);
1361   return _impl_.functions_;
1362 }
1363 inline ::google::protobuf::RepeatedPtrField<::onnx::FunctionProto>*
1364 OperatorSetProto::_internal_mutable_functions() {
1365   ::google::protobuf::internal::TSanRead(&_impl_);
1366   return &_impl_.functions_;
1367 }
1368 
1369 #ifdef __GNUC__
1370 #pragma GCC diagnostic pop
1371 #endif  // __GNUC__
1372 
1373 // @@protoc_insertion_point(namespace_scope)
1374 }  // namespace onnx
1375 
1376 
1377 // @@protoc_insertion_point(global_scope)
1378 
1379 #include "google/protobuf/port_undef.inc"
1380 
1381 #endif  // GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2doperators_2dml_2eproto_2epb_2eh
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!