1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: onnx/onnx-data_onnx_torch.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3013000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata_lite.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36#include "onnx/onnx_onnx_torch-ml.pb.h"
37// @@protoc_insertion_point(includes)
38#include <google/protobuf/port_def.inc>
39#define PROTOBUF_INTERNAL_EXPORT_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto ONNX_API
40PROTOBUF_NAMESPACE_OPEN
41namespace internal {
42class AnyMetadata;
43} // namespace internal
44PROTOBUF_NAMESPACE_CLOSE
45
46// Internal implementation detail -- do not use these members.
47struct ONNX_API TableStruct_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto {
48 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
49 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
50 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
51 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
52 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
53 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
54 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
55 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
56 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
57};
58extern ONNX_API const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto;
59namespace onnx_torch { const ::std::string& GetEmptyStringAlreadyInited();
60class MapProto;
61class MapProtoDefaultTypeInternal;
62ONNX_API extern MapProtoDefaultTypeInternal _MapProto_default_instance_;
63class OptionalProto;
64class OptionalProtoDefaultTypeInternal;
65ONNX_API extern OptionalProtoDefaultTypeInternal _OptionalProto_default_instance_;
66class SequenceProto;
67class SequenceProtoDefaultTypeInternal;
68ONNX_API extern SequenceProtoDefaultTypeInternal _SequenceProto_default_instance_;
69} // namespace onnx_torch
70PROTOBUF_NAMESPACE_OPEN
71template<> ONNX_API ::onnx_torch::MapProto* Arena::CreateMaybeMessage<::onnx_torch::MapProto>(Arena*);
72template<> ONNX_API ::onnx_torch::OptionalProto* Arena::CreateMaybeMessage<::onnx_torch::OptionalProto>(Arena*);
73template<> ONNX_API ::onnx_torch::SequenceProto* Arena::CreateMaybeMessage<::onnx_torch::SequenceProto>(Arena*);
74PROTOBUF_NAMESPACE_CLOSE
75namespace onnx_torch {
76
77enum SequenceProto_DataType : int {
78 SequenceProto_DataType_UNDEFINED = 0,
79 SequenceProto_DataType_TENSOR = 1,
80 SequenceProto_DataType_SPARSE_TENSOR = 2,
81 SequenceProto_DataType_SEQUENCE = 3,
82 SequenceProto_DataType_MAP = 4,
83 SequenceProto_DataType_OPTIONAL = 5
84};
85ONNX_API bool SequenceProto_DataType_IsValid(int value);
86constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MIN = SequenceProto_DataType_UNDEFINED;
87constexpr SequenceProto_DataType SequenceProto_DataType_DataType_MAX = SequenceProto_DataType_OPTIONAL;
88constexpr int SequenceProto_DataType_DataType_ARRAYSIZE = static_cast<int>(SequenceProto_DataType_DataType_MAX) + 1;
89
90ONNX_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SequenceProto_DataType_descriptor();
91template<typename T>
92inline const std::string& SequenceProto_DataType_Name(T enum_t_value) {
93 static_assert(::std::is_same<T, SequenceProto_DataType>::value ||
94 ::std::is_integral<T>::value,
95 "Incorrect type passed to function SequenceProto_DataType_Name.");
96 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
97 SequenceProto_DataType_descriptor(), enum_t_value);
98}
99inline bool SequenceProto_DataType_Parse(
100 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SequenceProto_DataType* value) {
101 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SequenceProto_DataType>(
102 SequenceProto_DataType_descriptor(), name, value);
103}
104enum OptionalProto_DataType : int {
105 OptionalProto_DataType_UNDEFINED = 0,
106 OptionalProto_DataType_TENSOR = 1,
107 OptionalProto_DataType_SPARSE_TENSOR = 2,
108 OptionalProto_DataType_SEQUENCE = 3,
109 OptionalProto_DataType_MAP = 4,
110 OptionalProto_DataType_OPTIONAL = 5
111};
112ONNX_API bool OptionalProto_DataType_IsValid(int value);
113constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MIN = OptionalProto_DataType_UNDEFINED;
114constexpr OptionalProto_DataType OptionalProto_DataType_DataType_MAX = OptionalProto_DataType_OPTIONAL;
115constexpr int OptionalProto_DataType_DataType_ARRAYSIZE = static_cast<int>(OptionalProto_DataType_DataType_MAX) + 1;
116
117ONNX_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OptionalProto_DataType_descriptor();
118template<typename T>
119inline const std::string& OptionalProto_DataType_Name(T enum_t_value) {
120 static_assert(::std::is_same<T, OptionalProto_DataType>::value ||
121 ::std::is_integral<T>::value,
122 "Incorrect type passed to function OptionalProto_DataType_Name.");
123 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
124 OptionalProto_DataType_descriptor(), enum_t_value);
125}
126inline bool OptionalProto_DataType_Parse(
127 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OptionalProto_DataType* value) {
128 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OptionalProto_DataType>(
129 OptionalProto_DataType_descriptor(), name, value);
130}
131// ===================================================================
132
133class ONNX_API SequenceProto PROTOBUF_FINAL :
134 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:onnx_torch.SequenceProto) */ {
135 public:
136 inline SequenceProto() : SequenceProto(nullptr) {}
137 virtual ~SequenceProto();
138
139 SequenceProto(const SequenceProto& from);
140 SequenceProto(SequenceProto&& from) noexcept;
141
142 inline SequenceProto& operator=(const SequenceProto& from) {
143 CopyFrom(from);
144 return *this;
145 }
146 inline SequenceProto& operator=(SequenceProto&& from) noexcept {
147 if (GetArena() == from.GetArena()) {
148 if (this != &from) InternalSwap(&from);
149 } else {
150 CopyFrom(from);
151 }
152 return *this;
153 }
154
155 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
156 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
157 }
158 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
159 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
160 }
161
162 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
163 return GetDescriptor();
164 }
165 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
166 return GetMetadataStatic().descriptor;
167 }
168 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
169 return GetMetadataStatic().reflection;
170 }
171 static const SequenceProto& default_instance();
172
173 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
174 static inline const SequenceProto* internal_default_instance() {
175 return reinterpret_cast<const SequenceProto*>(
176 &_SequenceProto_default_instance_);
177 }
178 static constexpr int kIndexInFileMessages =
179 0;
180
181 friend void swap(SequenceProto& a, SequenceProto& b) {
182 a.Swap(&b);
183 }
184 inline void Swap(SequenceProto* other) {
185 if (other == this) return;
186 if (GetArena() == other->GetArena()) {
187 InternalSwap(other);
188 } else {
189 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
190 }
191 }
192 void UnsafeArenaSwap(SequenceProto* other) {
193 if (other == this) return;
194 GOOGLE_DCHECK(GetArena() == other->GetArena());
195 InternalSwap(other);
196 }
197
198 // implements Message ----------------------------------------------
199
200 inline SequenceProto* New() const final {
201 return CreateMaybeMessage<SequenceProto>(nullptr);
202 }
203
204 SequenceProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
205 return CreateMaybeMessage<SequenceProto>(arena);
206 }
207 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
208 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
209 void CopyFrom(const SequenceProto& from);
210 void MergeFrom(const SequenceProto& from);
211 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
212 bool IsInitialized() const final;
213
214 size_t ByteSizeLong() const final;
215 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
216 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
217 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
218 int GetCachedSize() const final { return _cached_size_.Get(); }
219
220 private:
221 inline void SharedCtor();
222 inline void SharedDtor();
223 void SetCachedSize(int size) const final;
224 void InternalSwap(SequenceProto* other);
225 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
226 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
227 return "onnx_torch.SequenceProto";
228 }
229 protected:
230 explicit SequenceProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
231 private:
232 static void ArenaDtor(void* object);
233 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
234 public:
235
236 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
237 private:
238 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
239 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto);
240 return ::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto.file_level_metadata[kIndexInFileMessages];
241 }
242
243 public:
244
245 // nested types ----------------------------------------------------
246
247 typedef SequenceProto_DataType DataType;
248 static constexpr DataType UNDEFINED =
249 SequenceProto_DataType_UNDEFINED;
250 static constexpr DataType TENSOR =
251 SequenceProto_DataType_TENSOR;
252 static constexpr DataType SPARSE_TENSOR =
253 SequenceProto_DataType_SPARSE_TENSOR;
254 static constexpr DataType SEQUENCE =
255 SequenceProto_DataType_SEQUENCE;
256 static constexpr DataType MAP =
257 SequenceProto_DataType_MAP;
258 static constexpr DataType OPTIONAL =
259 SequenceProto_DataType_OPTIONAL;
260 static inline bool DataType_IsValid(int value) {
261 return SequenceProto_DataType_IsValid(value);
262 }
263 static constexpr DataType DataType_MIN =
264 SequenceProto_DataType_DataType_MIN;
265 static constexpr DataType DataType_MAX =
266 SequenceProto_DataType_DataType_MAX;
267 static constexpr int DataType_ARRAYSIZE =
268 SequenceProto_DataType_DataType_ARRAYSIZE;
269 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
270 DataType_descriptor() {
271 return SequenceProto_DataType_descriptor();
272 }
273 template<typename T>
274 static inline const std::string& DataType_Name(T enum_t_value) {
275 static_assert(::std::is_same<T, DataType>::value ||
276 ::std::is_integral<T>::value,
277 "Incorrect type passed to function DataType_Name.");
278 return SequenceProto_DataType_Name(enum_t_value);
279 }
280 static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
281 DataType* value) {
282 return SequenceProto_DataType_Parse(name, value);
283 }
284
285 // accessors -------------------------------------------------------
286
287 enum : int {
288 kTensorValuesFieldNumber = 3,
289 kSparseTensorValuesFieldNumber = 4,
290 kSequenceValuesFieldNumber = 5,
291 kMapValuesFieldNumber = 6,
292 kOptionalValuesFieldNumber = 7,
293 kNameFieldNumber = 1,
294 kElemTypeFieldNumber = 2,
295 };
296 // repeated .onnx_torch.TensorProto tensor_values = 3;
297 int tensor_values_size() const;
298 private:
299 int _internal_tensor_values_size() const;
300 public:
301 void clear_tensor_values();
302 ::onnx_torch::TensorProto* mutable_tensor_values(int index);
303 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::TensorProto >*
304 mutable_tensor_values();
305 private:
306 const ::onnx_torch::TensorProto& _internal_tensor_values(int index) const;
307 ::onnx_torch::TensorProto* _internal_add_tensor_values();
308 public:
309 const ::onnx_torch::TensorProto& tensor_values(int index) const;
310 ::onnx_torch::TensorProto* add_tensor_values();
311 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::TensorProto >&
312 tensor_values() const;
313
314 // repeated .onnx_torch.SparseTensorProto sparse_tensor_values = 4;
315 int sparse_tensor_values_size() const;
316 private:
317 int _internal_sparse_tensor_values_size() const;
318 public:
319 void clear_sparse_tensor_values();
320 ::onnx_torch::SparseTensorProto* mutable_sparse_tensor_values(int index);
321 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SparseTensorProto >*
322 mutable_sparse_tensor_values();
323 private:
324 const ::onnx_torch::SparseTensorProto& _internal_sparse_tensor_values(int index) const;
325 ::onnx_torch::SparseTensorProto* _internal_add_sparse_tensor_values();
326 public:
327 const ::onnx_torch::SparseTensorProto& sparse_tensor_values(int index) const;
328 ::onnx_torch::SparseTensorProto* add_sparse_tensor_values();
329 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SparseTensorProto >&
330 sparse_tensor_values() const;
331
332 // repeated .onnx_torch.SequenceProto sequence_values = 5;
333 int sequence_values_size() const;
334 private:
335 int _internal_sequence_values_size() const;
336 public:
337 void clear_sequence_values();
338 ::onnx_torch::SequenceProto* mutable_sequence_values(int index);
339 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SequenceProto >*
340 mutable_sequence_values();
341 private:
342 const ::onnx_torch::SequenceProto& _internal_sequence_values(int index) const;
343 ::onnx_torch::SequenceProto* _internal_add_sequence_values();
344 public:
345 const ::onnx_torch::SequenceProto& sequence_values(int index) const;
346 ::onnx_torch::SequenceProto* add_sequence_values();
347 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SequenceProto >&
348 sequence_values() const;
349
350 // repeated .onnx_torch.MapProto map_values = 6;
351 int map_values_size() const;
352 private:
353 int _internal_map_values_size() const;
354 public:
355 void clear_map_values();
356 ::onnx_torch::MapProto* mutable_map_values(int index);
357 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::MapProto >*
358 mutable_map_values();
359 private:
360 const ::onnx_torch::MapProto& _internal_map_values(int index) const;
361 ::onnx_torch::MapProto* _internal_add_map_values();
362 public:
363 const ::onnx_torch::MapProto& map_values(int index) const;
364 ::onnx_torch::MapProto* add_map_values();
365 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::MapProto >&
366 map_values() const;
367
368 // repeated .onnx_torch.OptionalProto optional_values = 7;
369 int optional_values_size() const;
370 private:
371 int _internal_optional_values_size() const;
372 public:
373 void clear_optional_values();
374 ::onnx_torch::OptionalProto* mutable_optional_values(int index);
375 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::OptionalProto >*
376 mutable_optional_values();
377 private:
378 const ::onnx_torch::OptionalProto& _internal_optional_values(int index) const;
379 ::onnx_torch::OptionalProto* _internal_add_optional_values();
380 public:
381 const ::onnx_torch::OptionalProto& optional_values(int index) const;
382 ::onnx_torch::OptionalProto* add_optional_values();
383 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::OptionalProto >&
384 optional_values() const;
385
386 // optional string name = 1;
387 bool has_name() const;
388 private:
389 bool _internal_has_name() const;
390 public:
391 void clear_name();
392 const std::string& name() const;
393 void set_name(const std::string& value);
394 void set_name(std::string&& value);
395 void set_name(const char* value);
396 void set_name(const char* value, size_t size);
397 std::string* mutable_name();
398 std::string* release_name();
399 void set_allocated_name(std::string* name);
400 private:
401 const std::string& _internal_name() const;
402 void _internal_set_name(const std::string& value);
403 std::string* _internal_mutable_name();
404 public:
405
406 // optional int32 elem_type = 2;
407 bool has_elem_type() const;
408 private:
409 bool _internal_has_elem_type() const;
410 public:
411 void clear_elem_type();
412 ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
413 void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
414 private:
415 ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
416 void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
417 public:
418
419 // @@protoc_insertion_point(class_scope:onnx_torch.SequenceProto)
420 private:
421 class _Internal;
422
423 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
424 typedef void InternalArenaConstructable_;
425 typedef void DestructorSkippable_;
426 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
427 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
428 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::TensorProto > tensor_values_;
429 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SparseTensorProto > sparse_tensor_values_;
430 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SequenceProto > sequence_values_;
431 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::MapProto > map_values_;
432 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::OptionalProto > optional_values_;
433 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
434 ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
435 friend struct ::TableStruct_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto;
436};
437// -------------------------------------------------------------------
438
439class ONNX_API MapProto PROTOBUF_FINAL :
440 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:onnx_torch.MapProto) */ {
441 public:
442 inline MapProto() : MapProto(nullptr) {}
443 virtual ~MapProto();
444
445 MapProto(const MapProto& from);
446 MapProto(MapProto&& from) noexcept;
447
448 inline MapProto& operator=(const MapProto& from) {
449 CopyFrom(from);
450 return *this;
451 }
452 inline MapProto& operator=(MapProto&& from) noexcept {
453 if (GetArena() == from.GetArena()) {
454 if (this != &from) InternalSwap(&from);
455 } else {
456 CopyFrom(from);
457 }
458 return *this;
459 }
460
461 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
462 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
463 }
464 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
465 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
466 }
467
468 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
469 return GetDescriptor();
470 }
471 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
472 return GetMetadataStatic().descriptor;
473 }
474 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
475 return GetMetadataStatic().reflection;
476 }
477 static const MapProto& default_instance();
478
479 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
480 static inline const MapProto* internal_default_instance() {
481 return reinterpret_cast<const MapProto*>(
482 &_MapProto_default_instance_);
483 }
484 static constexpr int kIndexInFileMessages =
485 1;
486
487 friend void swap(MapProto& a, MapProto& b) {
488 a.Swap(&b);
489 }
490 inline void Swap(MapProto* other) {
491 if (other == this) return;
492 if (GetArena() == other->GetArena()) {
493 InternalSwap(other);
494 } else {
495 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
496 }
497 }
498 void UnsafeArenaSwap(MapProto* other) {
499 if (other == this) return;
500 GOOGLE_DCHECK(GetArena() == other->GetArena());
501 InternalSwap(other);
502 }
503
504 // implements Message ----------------------------------------------
505
506 inline MapProto* New() const final {
507 return CreateMaybeMessage<MapProto>(nullptr);
508 }
509
510 MapProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
511 return CreateMaybeMessage<MapProto>(arena);
512 }
513 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
514 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
515 void CopyFrom(const MapProto& from);
516 void MergeFrom(const MapProto& from);
517 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
518 bool IsInitialized() const final;
519
520 size_t ByteSizeLong() const final;
521 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
522 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
523 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
524 int GetCachedSize() const final { return _cached_size_.Get(); }
525
526 private:
527 inline void SharedCtor();
528 inline void SharedDtor();
529 void SetCachedSize(int size) const final;
530 void InternalSwap(MapProto* other);
531 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
532 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
533 return "onnx_torch.MapProto";
534 }
535 protected:
536 explicit MapProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
537 private:
538 static void ArenaDtor(void* object);
539 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
540 public:
541
542 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
543 private:
544 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
545 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto);
546 return ::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto.file_level_metadata[kIndexInFileMessages];
547 }
548
549 public:
550
551 // nested types ----------------------------------------------------
552
553 // accessors -------------------------------------------------------
554
555 enum : int {
556 kKeysFieldNumber = 3,
557 kStringKeysFieldNumber = 4,
558 kNameFieldNumber = 1,
559 kValuesFieldNumber = 5,
560 kKeyTypeFieldNumber = 2,
561 };
562 // repeated int64 keys = 3;
563 int keys_size() const;
564 private:
565 int _internal_keys_size() const;
566 public:
567 void clear_keys();
568 private:
569 ::PROTOBUF_NAMESPACE_ID::int64 _internal_keys(int index) const;
570 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
571 _internal_keys() const;
572 void _internal_add_keys(::PROTOBUF_NAMESPACE_ID::int64 value);
573 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
574 _internal_mutable_keys();
575 public:
576 ::PROTOBUF_NAMESPACE_ID::int64 keys(int index) const;
577 void set_keys(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
578 void add_keys(::PROTOBUF_NAMESPACE_ID::int64 value);
579 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
580 keys() const;
581 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
582 mutable_keys();
583
584 // repeated bytes string_keys = 4;
585 int string_keys_size() const;
586 private:
587 int _internal_string_keys_size() const;
588 public:
589 void clear_string_keys();
590 const std::string& string_keys(int index) const;
591 std::string* mutable_string_keys(int index);
592 void set_string_keys(int index, const std::string& value);
593 void set_string_keys(int index, std::string&& value);
594 void set_string_keys(int index, const char* value);
595 void set_string_keys(int index, const void* value, size_t size);
596 std::string* add_string_keys();
597 void add_string_keys(const std::string& value);
598 void add_string_keys(std::string&& value);
599 void add_string_keys(const char* value);
600 void add_string_keys(const void* value, size_t size);
601 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_keys() const;
602 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_keys();
603 private:
604 const std::string& _internal_string_keys(int index) const;
605 std::string* _internal_add_string_keys();
606 public:
607
608 // optional string name = 1;
609 bool has_name() const;
610 private:
611 bool _internal_has_name() const;
612 public:
613 void clear_name();
614 const std::string& name() const;
615 void set_name(const std::string& value);
616 void set_name(std::string&& value);
617 void set_name(const char* value);
618 void set_name(const char* value, size_t size);
619 std::string* mutable_name();
620 std::string* release_name();
621 void set_allocated_name(std::string* name);
622 private:
623 const std::string& _internal_name() const;
624 void _internal_set_name(const std::string& value);
625 std::string* _internal_mutable_name();
626 public:
627
628 // optional .onnx_torch.SequenceProto values = 5;
629 bool has_values() const;
630 private:
631 bool _internal_has_values() const;
632 public:
633 void clear_values();
634 const ::onnx_torch::SequenceProto& values() const;
635 ::onnx_torch::SequenceProto* release_values();
636 ::onnx_torch::SequenceProto* mutable_values();
637 void set_allocated_values(::onnx_torch::SequenceProto* values);
638 private:
639 const ::onnx_torch::SequenceProto& _internal_values() const;
640 ::onnx_torch::SequenceProto* _internal_mutable_values();
641 public:
642 void unsafe_arena_set_allocated_values(
643 ::onnx_torch::SequenceProto* values);
644 ::onnx_torch::SequenceProto* unsafe_arena_release_values();
645
646 // optional int32 key_type = 2;
647 bool has_key_type() const;
648 private:
649 bool _internal_has_key_type() const;
650 public:
651 void clear_key_type();
652 ::PROTOBUF_NAMESPACE_ID::int32 key_type() const;
653 void set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
654 private:
655 ::PROTOBUF_NAMESPACE_ID::int32 _internal_key_type() const;
656 void _internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value);
657 public:
658
659 // @@protoc_insertion_point(class_scope:onnx_torch.MapProto)
660 private:
661 class _Internal;
662
663 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
664 typedef void InternalArenaConstructable_;
665 typedef void DestructorSkippable_;
666 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
667 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
668 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > keys_;
669 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_keys_;
670 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
671 ::onnx_torch::SequenceProto* values_;
672 ::PROTOBUF_NAMESPACE_ID::int32 key_type_;
673 friend struct ::TableStruct_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto;
674};
675// -------------------------------------------------------------------
676
677class ONNX_API OptionalProto PROTOBUF_FINAL :
678 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:onnx_torch.OptionalProto) */ {
679 public:
680 inline OptionalProto() : OptionalProto(nullptr) {}
681 virtual ~OptionalProto();
682
683 OptionalProto(const OptionalProto& from);
684 OptionalProto(OptionalProto&& from) noexcept;
685
686 inline OptionalProto& operator=(const OptionalProto& from) {
687 CopyFrom(from);
688 return *this;
689 }
690 inline OptionalProto& operator=(OptionalProto&& from) noexcept {
691 if (GetArena() == from.GetArena()) {
692 if (this != &from) InternalSwap(&from);
693 } else {
694 CopyFrom(from);
695 }
696 return *this;
697 }
698
699 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
700 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
701 }
702 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
703 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
704 }
705
706 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
707 return GetDescriptor();
708 }
709 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
710 return GetMetadataStatic().descriptor;
711 }
712 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
713 return GetMetadataStatic().reflection;
714 }
715 static const OptionalProto& default_instance();
716
717 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
718 static inline const OptionalProto* internal_default_instance() {
719 return reinterpret_cast<const OptionalProto*>(
720 &_OptionalProto_default_instance_);
721 }
722 static constexpr int kIndexInFileMessages =
723 2;
724
725 friend void swap(OptionalProto& a, OptionalProto& b) {
726 a.Swap(&b);
727 }
728 inline void Swap(OptionalProto* other) {
729 if (other == this) return;
730 if (GetArena() == other->GetArena()) {
731 InternalSwap(other);
732 } else {
733 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
734 }
735 }
736 void UnsafeArenaSwap(OptionalProto* other) {
737 if (other == this) return;
738 GOOGLE_DCHECK(GetArena() == other->GetArena());
739 InternalSwap(other);
740 }
741
742 // implements Message ----------------------------------------------
743
744 inline OptionalProto* New() const final {
745 return CreateMaybeMessage<OptionalProto>(nullptr);
746 }
747
748 OptionalProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
749 return CreateMaybeMessage<OptionalProto>(arena);
750 }
751 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
752 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
753 void CopyFrom(const OptionalProto& from);
754 void MergeFrom(const OptionalProto& from);
755 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
756 bool IsInitialized() const final;
757
758 size_t ByteSizeLong() const final;
759 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
760 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
761 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
762 int GetCachedSize() const final { return _cached_size_.Get(); }
763
764 private:
765 inline void SharedCtor();
766 inline void SharedDtor();
767 void SetCachedSize(int size) const final;
768 void InternalSwap(OptionalProto* other);
769 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
770 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
771 return "onnx_torch.OptionalProto";
772 }
773 protected:
774 explicit OptionalProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
775 private:
776 static void ArenaDtor(void* object);
777 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
778 public:
779
780 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
781 private:
782 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
783 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto);
784 return ::descriptor_table_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto.file_level_metadata[kIndexInFileMessages];
785 }
786
787 public:
788
789 // nested types ----------------------------------------------------
790
791 typedef OptionalProto_DataType DataType;
792 static constexpr DataType UNDEFINED =
793 OptionalProto_DataType_UNDEFINED;
794 static constexpr DataType TENSOR =
795 OptionalProto_DataType_TENSOR;
796 static constexpr DataType SPARSE_TENSOR =
797 OptionalProto_DataType_SPARSE_TENSOR;
798 static constexpr DataType SEQUENCE =
799 OptionalProto_DataType_SEQUENCE;
800 static constexpr DataType MAP =
801 OptionalProto_DataType_MAP;
802 static constexpr DataType OPTIONAL =
803 OptionalProto_DataType_OPTIONAL;
804 static inline bool DataType_IsValid(int value) {
805 return OptionalProto_DataType_IsValid(value);
806 }
807 static constexpr DataType DataType_MIN =
808 OptionalProto_DataType_DataType_MIN;
809 static constexpr DataType DataType_MAX =
810 OptionalProto_DataType_DataType_MAX;
811 static constexpr int DataType_ARRAYSIZE =
812 OptionalProto_DataType_DataType_ARRAYSIZE;
813 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
814 DataType_descriptor() {
815 return OptionalProto_DataType_descriptor();
816 }
817 template<typename T>
818 static inline const std::string& DataType_Name(T enum_t_value) {
819 static_assert(::std::is_same<T, DataType>::value ||
820 ::std::is_integral<T>::value,
821 "Incorrect type passed to function DataType_Name.");
822 return OptionalProto_DataType_Name(enum_t_value);
823 }
824 static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
825 DataType* value) {
826 return OptionalProto_DataType_Parse(name, value);
827 }
828
829 // accessors -------------------------------------------------------
830
831 enum : int {
832 kNameFieldNumber = 1,
833 kTensorValueFieldNumber = 3,
834 kSparseTensorValueFieldNumber = 4,
835 kSequenceValueFieldNumber = 5,
836 kMapValueFieldNumber = 6,
837 kOptionalValueFieldNumber = 7,
838 kElemTypeFieldNumber = 2,
839 };
840 // optional string name = 1;
841 bool has_name() const;
842 private:
843 bool _internal_has_name() const;
844 public:
845 void clear_name();
846 const std::string& name() const;
847 void set_name(const std::string& value);
848 void set_name(std::string&& value);
849 void set_name(const char* value);
850 void set_name(const char* value, size_t size);
851 std::string* mutable_name();
852 std::string* release_name();
853 void set_allocated_name(std::string* name);
854 private:
855 const std::string& _internal_name() const;
856 void _internal_set_name(const std::string& value);
857 std::string* _internal_mutable_name();
858 public:
859
860 // optional .onnx_torch.TensorProto tensor_value = 3;
861 bool has_tensor_value() const;
862 private:
863 bool _internal_has_tensor_value() const;
864 public:
865 void clear_tensor_value();
866 const ::onnx_torch::TensorProto& tensor_value() const;
867 ::onnx_torch::TensorProto* release_tensor_value();
868 ::onnx_torch::TensorProto* mutable_tensor_value();
869 void set_allocated_tensor_value(::onnx_torch::TensorProto* tensor_value);
870 private:
871 const ::onnx_torch::TensorProto& _internal_tensor_value() const;
872 ::onnx_torch::TensorProto* _internal_mutable_tensor_value();
873 public:
874 void unsafe_arena_set_allocated_tensor_value(
875 ::onnx_torch::TensorProto* tensor_value);
876 ::onnx_torch::TensorProto* unsafe_arena_release_tensor_value();
877
878 // optional .onnx_torch.SparseTensorProto sparse_tensor_value = 4;
879 bool has_sparse_tensor_value() const;
880 private:
881 bool _internal_has_sparse_tensor_value() const;
882 public:
883 void clear_sparse_tensor_value();
884 const ::onnx_torch::SparseTensorProto& sparse_tensor_value() const;
885 ::onnx_torch::SparseTensorProto* release_sparse_tensor_value();
886 ::onnx_torch::SparseTensorProto* mutable_sparse_tensor_value();
887 void set_allocated_sparse_tensor_value(::onnx_torch::SparseTensorProto* sparse_tensor_value);
888 private:
889 const ::onnx_torch::SparseTensorProto& _internal_sparse_tensor_value() const;
890 ::onnx_torch::SparseTensorProto* _internal_mutable_sparse_tensor_value();
891 public:
892 void unsafe_arena_set_allocated_sparse_tensor_value(
893 ::onnx_torch::SparseTensorProto* sparse_tensor_value);
894 ::onnx_torch::SparseTensorProto* unsafe_arena_release_sparse_tensor_value();
895
896 // optional .onnx_torch.SequenceProto sequence_value = 5;
897 bool has_sequence_value() const;
898 private:
899 bool _internal_has_sequence_value() const;
900 public:
901 void clear_sequence_value();
902 const ::onnx_torch::SequenceProto& sequence_value() const;
903 ::onnx_torch::SequenceProto* release_sequence_value();
904 ::onnx_torch::SequenceProto* mutable_sequence_value();
905 void set_allocated_sequence_value(::onnx_torch::SequenceProto* sequence_value);
906 private:
907 const ::onnx_torch::SequenceProto& _internal_sequence_value() const;
908 ::onnx_torch::SequenceProto* _internal_mutable_sequence_value();
909 public:
910 void unsafe_arena_set_allocated_sequence_value(
911 ::onnx_torch::SequenceProto* sequence_value);
912 ::onnx_torch::SequenceProto* unsafe_arena_release_sequence_value();
913
914 // optional .onnx_torch.MapProto map_value = 6;
915 bool has_map_value() const;
916 private:
917 bool _internal_has_map_value() const;
918 public:
919 void clear_map_value();
920 const ::onnx_torch::MapProto& map_value() const;
921 ::onnx_torch::MapProto* release_map_value();
922 ::onnx_torch::MapProto* mutable_map_value();
923 void set_allocated_map_value(::onnx_torch::MapProto* map_value);
924 private:
925 const ::onnx_torch::MapProto& _internal_map_value() const;
926 ::onnx_torch::MapProto* _internal_mutable_map_value();
927 public:
928 void unsafe_arena_set_allocated_map_value(
929 ::onnx_torch::MapProto* map_value);
930 ::onnx_torch::MapProto* unsafe_arena_release_map_value();
931
932 // optional .onnx_torch.OptionalProto optional_value = 7;
933 bool has_optional_value() const;
934 private:
935 bool _internal_has_optional_value() const;
936 public:
937 void clear_optional_value();
938 const ::onnx_torch::OptionalProto& optional_value() const;
939 ::onnx_torch::OptionalProto* release_optional_value();
940 ::onnx_torch::OptionalProto* mutable_optional_value();
941 void set_allocated_optional_value(::onnx_torch::OptionalProto* optional_value);
942 private:
943 const ::onnx_torch::OptionalProto& _internal_optional_value() const;
944 ::onnx_torch::OptionalProto* _internal_mutable_optional_value();
945 public:
946 void unsafe_arena_set_allocated_optional_value(
947 ::onnx_torch::OptionalProto* optional_value);
948 ::onnx_torch::OptionalProto* unsafe_arena_release_optional_value();
949
950 // optional int32 elem_type = 2;
951 bool has_elem_type() const;
952 private:
953 bool _internal_has_elem_type() const;
954 public:
955 void clear_elem_type();
956 ::PROTOBUF_NAMESPACE_ID::int32 elem_type() const;
957 void set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
958 private:
959 ::PROTOBUF_NAMESPACE_ID::int32 _internal_elem_type() const;
960 void _internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value);
961 public:
962
963 // @@protoc_insertion_point(class_scope:onnx_torch.OptionalProto)
964 private:
965 class _Internal;
966
967 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
968 typedef void InternalArenaConstructable_;
969 typedef void DestructorSkippable_;
970 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
971 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
972 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
973 ::onnx_torch::TensorProto* tensor_value_;
974 ::onnx_torch::SparseTensorProto* sparse_tensor_value_;
975 ::onnx_torch::SequenceProto* sequence_value_;
976 ::onnx_torch::MapProto* map_value_;
977 ::onnx_torch::OptionalProto* optional_value_;
978 ::PROTOBUF_NAMESPACE_ID::int32 elem_type_;
979 friend struct ::TableStruct_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto;
980};
981// ===================================================================
982
983
984// ===================================================================
985
986#ifdef __GNUC__
987 #pragma GCC diagnostic push
988 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
989#endif // __GNUC__
990// SequenceProto
991
992// optional string name = 1;
993inline bool SequenceProto::_internal_has_name() const {
994 bool value = (_has_bits_[0] & 0x00000001u) != 0;
995 return value;
996}
997inline bool SequenceProto::has_name() const {
998 return _internal_has_name();
999}
1000inline void SequenceProto::clear_name() {
1001 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
1002 _has_bits_[0] &= ~0x00000001u;
1003}
1004inline const std::string& SequenceProto::name() const {
1005 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.name)
1006 return _internal_name();
1007}
1008inline void SequenceProto::set_name(const std::string& value) {
1009 _internal_set_name(value);
1010 // @@protoc_insertion_point(field_set:onnx_torch.SequenceProto.name)
1011}
1012inline std::string* SequenceProto::mutable_name() {
1013 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.name)
1014 return _internal_mutable_name();
1015}
1016inline const std::string& SequenceProto::_internal_name() const {
1017 return name_.Get();
1018}
1019inline void SequenceProto::_internal_set_name(const std::string& value) {
1020 _has_bits_[0] |= 0x00000001u;
1021 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
1022}
1023inline void SequenceProto::set_name(std::string&& value) {
1024 _has_bits_[0] |= 0x00000001u;
1025 name_.Set(
1026 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
1027 // @@protoc_insertion_point(field_set_rvalue:onnx_torch.SequenceProto.name)
1028}
1029inline void SequenceProto::set_name(const char* value) {
1030 GOOGLE_DCHECK(value != nullptr);
1031 _has_bits_[0] |= 0x00000001u;
1032 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
1033 GetArena());
1034 // @@protoc_insertion_point(field_set_char:onnx_torch.SequenceProto.name)
1035}
1036inline void SequenceProto::set_name(const char* value,
1037 size_t size) {
1038 _has_bits_[0] |= 0x00000001u;
1039 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
1040 reinterpret_cast<const char*>(value), size), GetArena());
1041 // @@protoc_insertion_point(field_set_pointer:onnx_torch.SequenceProto.name)
1042}
1043inline std::string* SequenceProto::_internal_mutable_name() {
1044 _has_bits_[0] |= 0x00000001u;
1045 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
1046}
1047inline std::string* SequenceProto::release_name() {
1048 // @@protoc_insertion_point(field_release:onnx_torch.SequenceProto.name)
1049 if (!_internal_has_name()) {
1050 return nullptr;
1051 }
1052 _has_bits_[0] &= ~0x00000001u;
1053 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
1054}
1055inline void SequenceProto::set_allocated_name(std::string* name) {
1056 if (name != nullptr) {
1057 _has_bits_[0] |= 0x00000001u;
1058 } else {
1059 _has_bits_[0] &= ~0x00000001u;
1060 }
1061 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
1062 GetArena());
1063 // @@protoc_insertion_point(field_set_allocated:onnx_torch.SequenceProto.name)
1064}
1065
1066// optional int32 elem_type = 2;
1067inline bool SequenceProto::_internal_has_elem_type() const {
1068 bool value = (_has_bits_[0] & 0x00000002u) != 0;
1069 return value;
1070}
1071inline bool SequenceProto::has_elem_type() const {
1072 return _internal_has_elem_type();
1073}
1074inline void SequenceProto::clear_elem_type() {
1075 elem_type_ = 0;
1076 _has_bits_[0] &= ~0x00000002u;
1077}
1078inline ::PROTOBUF_NAMESPACE_ID::int32 SequenceProto::_internal_elem_type() const {
1079 return elem_type_;
1080}
1081inline ::PROTOBUF_NAMESPACE_ID::int32 SequenceProto::elem_type() const {
1082 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.elem_type)
1083 return _internal_elem_type();
1084}
1085inline void SequenceProto::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1086 _has_bits_[0] |= 0x00000002u;
1087 elem_type_ = value;
1088}
1089inline void SequenceProto::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1090 _internal_set_elem_type(value);
1091 // @@protoc_insertion_point(field_set:onnx_torch.SequenceProto.elem_type)
1092}
1093
1094// repeated .onnx_torch.TensorProto tensor_values = 3;
1095inline int SequenceProto::_internal_tensor_values_size() const {
1096 return tensor_values_.size();
1097}
1098inline int SequenceProto::tensor_values_size() const {
1099 return _internal_tensor_values_size();
1100}
1101inline ::onnx_torch::TensorProto* SequenceProto::mutable_tensor_values(int index) {
1102 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.tensor_values)
1103 return tensor_values_.Mutable(index);
1104}
1105inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::TensorProto >*
1106SequenceProto::mutable_tensor_values() {
1107 // @@protoc_insertion_point(field_mutable_list:onnx_torch.SequenceProto.tensor_values)
1108 return &tensor_values_;
1109}
1110inline const ::onnx_torch::TensorProto& SequenceProto::_internal_tensor_values(int index) const {
1111 return tensor_values_.Get(index);
1112}
1113inline const ::onnx_torch::TensorProto& SequenceProto::tensor_values(int index) const {
1114 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.tensor_values)
1115 return _internal_tensor_values(index);
1116}
1117inline ::onnx_torch::TensorProto* SequenceProto::_internal_add_tensor_values() {
1118 return tensor_values_.Add();
1119}
1120inline ::onnx_torch::TensorProto* SequenceProto::add_tensor_values() {
1121 // @@protoc_insertion_point(field_add:onnx_torch.SequenceProto.tensor_values)
1122 return _internal_add_tensor_values();
1123}
1124inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::TensorProto >&
1125SequenceProto::tensor_values() const {
1126 // @@protoc_insertion_point(field_list:onnx_torch.SequenceProto.tensor_values)
1127 return tensor_values_;
1128}
1129
1130// repeated .onnx_torch.SparseTensorProto sparse_tensor_values = 4;
1131inline int SequenceProto::_internal_sparse_tensor_values_size() const {
1132 return sparse_tensor_values_.size();
1133}
1134inline int SequenceProto::sparse_tensor_values_size() const {
1135 return _internal_sparse_tensor_values_size();
1136}
1137inline ::onnx_torch::SparseTensorProto* SequenceProto::mutable_sparse_tensor_values(int index) {
1138 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.sparse_tensor_values)
1139 return sparse_tensor_values_.Mutable(index);
1140}
1141inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SparseTensorProto >*
1142SequenceProto::mutable_sparse_tensor_values() {
1143 // @@protoc_insertion_point(field_mutable_list:onnx_torch.SequenceProto.sparse_tensor_values)
1144 return &sparse_tensor_values_;
1145}
1146inline const ::onnx_torch::SparseTensorProto& SequenceProto::_internal_sparse_tensor_values(int index) const {
1147 return sparse_tensor_values_.Get(index);
1148}
1149inline const ::onnx_torch::SparseTensorProto& SequenceProto::sparse_tensor_values(int index) const {
1150 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.sparse_tensor_values)
1151 return _internal_sparse_tensor_values(index);
1152}
1153inline ::onnx_torch::SparseTensorProto* SequenceProto::_internal_add_sparse_tensor_values() {
1154 return sparse_tensor_values_.Add();
1155}
1156inline ::onnx_torch::SparseTensorProto* SequenceProto::add_sparse_tensor_values() {
1157 // @@protoc_insertion_point(field_add:onnx_torch.SequenceProto.sparse_tensor_values)
1158 return _internal_add_sparse_tensor_values();
1159}
1160inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SparseTensorProto >&
1161SequenceProto::sparse_tensor_values() const {
1162 // @@protoc_insertion_point(field_list:onnx_torch.SequenceProto.sparse_tensor_values)
1163 return sparse_tensor_values_;
1164}
1165
1166// repeated .onnx_torch.SequenceProto sequence_values = 5;
1167inline int SequenceProto::_internal_sequence_values_size() const {
1168 return sequence_values_.size();
1169}
1170inline int SequenceProto::sequence_values_size() const {
1171 return _internal_sequence_values_size();
1172}
1173inline void SequenceProto::clear_sequence_values() {
1174 sequence_values_.Clear();
1175}
1176inline ::onnx_torch::SequenceProto* SequenceProto::mutable_sequence_values(int index) {
1177 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.sequence_values)
1178 return sequence_values_.Mutable(index);
1179}
1180inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SequenceProto >*
1181SequenceProto::mutable_sequence_values() {
1182 // @@protoc_insertion_point(field_mutable_list:onnx_torch.SequenceProto.sequence_values)
1183 return &sequence_values_;
1184}
1185inline const ::onnx_torch::SequenceProto& SequenceProto::_internal_sequence_values(int index) const {
1186 return sequence_values_.Get(index);
1187}
1188inline const ::onnx_torch::SequenceProto& SequenceProto::sequence_values(int index) const {
1189 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.sequence_values)
1190 return _internal_sequence_values(index);
1191}
1192inline ::onnx_torch::SequenceProto* SequenceProto::_internal_add_sequence_values() {
1193 return sequence_values_.Add();
1194}
1195inline ::onnx_torch::SequenceProto* SequenceProto::add_sequence_values() {
1196 // @@protoc_insertion_point(field_add:onnx_torch.SequenceProto.sequence_values)
1197 return _internal_add_sequence_values();
1198}
1199inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::SequenceProto >&
1200SequenceProto::sequence_values() const {
1201 // @@protoc_insertion_point(field_list:onnx_torch.SequenceProto.sequence_values)
1202 return sequence_values_;
1203}
1204
1205// repeated .onnx_torch.MapProto map_values = 6;
1206inline int SequenceProto::_internal_map_values_size() const {
1207 return map_values_.size();
1208}
1209inline int SequenceProto::map_values_size() const {
1210 return _internal_map_values_size();
1211}
1212inline void SequenceProto::clear_map_values() {
1213 map_values_.Clear();
1214}
1215inline ::onnx_torch::MapProto* SequenceProto::mutable_map_values(int index) {
1216 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.map_values)
1217 return map_values_.Mutable(index);
1218}
1219inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::MapProto >*
1220SequenceProto::mutable_map_values() {
1221 // @@protoc_insertion_point(field_mutable_list:onnx_torch.SequenceProto.map_values)
1222 return &map_values_;
1223}
1224inline const ::onnx_torch::MapProto& SequenceProto::_internal_map_values(int index) const {
1225 return map_values_.Get(index);
1226}
1227inline const ::onnx_torch::MapProto& SequenceProto::map_values(int index) const {
1228 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.map_values)
1229 return _internal_map_values(index);
1230}
1231inline ::onnx_torch::MapProto* SequenceProto::_internal_add_map_values() {
1232 return map_values_.Add();
1233}
1234inline ::onnx_torch::MapProto* SequenceProto::add_map_values() {
1235 // @@protoc_insertion_point(field_add:onnx_torch.SequenceProto.map_values)
1236 return _internal_add_map_values();
1237}
1238inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::MapProto >&
1239SequenceProto::map_values() const {
1240 // @@protoc_insertion_point(field_list:onnx_torch.SequenceProto.map_values)
1241 return map_values_;
1242}
1243
1244// repeated .onnx_torch.OptionalProto optional_values = 7;
1245inline int SequenceProto::_internal_optional_values_size() const {
1246 return optional_values_.size();
1247}
1248inline int SequenceProto::optional_values_size() const {
1249 return _internal_optional_values_size();
1250}
1251inline void SequenceProto::clear_optional_values() {
1252 optional_values_.Clear();
1253}
1254inline ::onnx_torch::OptionalProto* SequenceProto::mutable_optional_values(int index) {
1255 // @@protoc_insertion_point(field_mutable:onnx_torch.SequenceProto.optional_values)
1256 return optional_values_.Mutable(index);
1257}
1258inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::OptionalProto >*
1259SequenceProto::mutable_optional_values() {
1260 // @@protoc_insertion_point(field_mutable_list:onnx_torch.SequenceProto.optional_values)
1261 return &optional_values_;
1262}
1263inline const ::onnx_torch::OptionalProto& SequenceProto::_internal_optional_values(int index) const {
1264 return optional_values_.Get(index);
1265}
1266inline const ::onnx_torch::OptionalProto& SequenceProto::optional_values(int index) const {
1267 // @@protoc_insertion_point(field_get:onnx_torch.SequenceProto.optional_values)
1268 return _internal_optional_values(index);
1269}
1270inline ::onnx_torch::OptionalProto* SequenceProto::_internal_add_optional_values() {
1271 return optional_values_.Add();
1272}
1273inline ::onnx_torch::OptionalProto* SequenceProto::add_optional_values() {
1274 // @@protoc_insertion_point(field_add:onnx_torch.SequenceProto.optional_values)
1275 return _internal_add_optional_values();
1276}
1277inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::onnx_torch::OptionalProto >&
1278SequenceProto::optional_values() const {
1279 // @@protoc_insertion_point(field_list:onnx_torch.SequenceProto.optional_values)
1280 return optional_values_;
1281}
1282
1283// -------------------------------------------------------------------
1284
1285// MapProto
1286
1287// optional string name = 1;
1288inline bool MapProto::_internal_has_name() const {
1289 bool value = (_has_bits_[0] & 0x00000001u) != 0;
1290 return value;
1291}
1292inline bool MapProto::has_name() const {
1293 return _internal_has_name();
1294}
1295inline void MapProto::clear_name() {
1296 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
1297 _has_bits_[0] &= ~0x00000001u;
1298}
1299inline const std::string& MapProto::name() const {
1300 // @@protoc_insertion_point(field_get:onnx_torch.MapProto.name)
1301 return _internal_name();
1302}
1303inline void MapProto::set_name(const std::string& value) {
1304 _internal_set_name(value);
1305 // @@protoc_insertion_point(field_set:onnx_torch.MapProto.name)
1306}
1307inline std::string* MapProto::mutable_name() {
1308 // @@protoc_insertion_point(field_mutable:onnx_torch.MapProto.name)
1309 return _internal_mutable_name();
1310}
1311inline const std::string& MapProto::_internal_name() const {
1312 return name_.Get();
1313}
1314inline void MapProto::_internal_set_name(const std::string& value) {
1315 _has_bits_[0] |= 0x00000001u;
1316 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
1317}
1318inline void MapProto::set_name(std::string&& value) {
1319 _has_bits_[0] |= 0x00000001u;
1320 name_.Set(
1321 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
1322 // @@protoc_insertion_point(field_set_rvalue:onnx_torch.MapProto.name)
1323}
1324inline void MapProto::set_name(const char* value) {
1325 GOOGLE_DCHECK(value != nullptr);
1326 _has_bits_[0] |= 0x00000001u;
1327 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
1328 GetArena());
1329 // @@protoc_insertion_point(field_set_char:onnx_torch.MapProto.name)
1330}
1331inline void MapProto::set_name(const char* value,
1332 size_t size) {
1333 _has_bits_[0] |= 0x00000001u;
1334 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
1335 reinterpret_cast<const char*>(value), size), GetArena());
1336 // @@protoc_insertion_point(field_set_pointer:onnx_torch.MapProto.name)
1337}
1338inline std::string* MapProto::_internal_mutable_name() {
1339 _has_bits_[0] |= 0x00000001u;
1340 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
1341}
1342inline std::string* MapProto::release_name() {
1343 // @@protoc_insertion_point(field_release:onnx_torch.MapProto.name)
1344 if (!_internal_has_name()) {
1345 return nullptr;
1346 }
1347 _has_bits_[0] &= ~0x00000001u;
1348 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
1349}
1350inline void MapProto::set_allocated_name(std::string* name) {
1351 if (name != nullptr) {
1352 _has_bits_[0] |= 0x00000001u;
1353 } else {
1354 _has_bits_[0] &= ~0x00000001u;
1355 }
1356 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
1357 GetArena());
1358 // @@protoc_insertion_point(field_set_allocated:onnx_torch.MapProto.name)
1359}
1360
1361// optional int32 key_type = 2;
1362inline bool MapProto::_internal_has_key_type() const {
1363 bool value = (_has_bits_[0] & 0x00000004u) != 0;
1364 return value;
1365}
1366inline bool MapProto::has_key_type() const {
1367 return _internal_has_key_type();
1368}
1369inline void MapProto::clear_key_type() {
1370 key_type_ = 0;
1371 _has_bits_[0] &= ~0x00000004u;
1372}
1373inline ::PROTOBUF_NAMESPACE_ID::int32 MapProto::_internal_key_type() const {
1374 return key_type_;
1375}
1376inline ::PROTOBUF_NAMESPACE_ID::int32 MapProto::key_type() const {
1377 // @@protoc_insertion_point(field_get:onnx_torch.MapProto.key_type)
1378 return _internal_key_type();
1379}
1380inline void MapProto::_internal_set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1381 _has_bits_[0] |= 0x00000004u;
1382 key_type_ = value;
1383}
1384inline void MapProto::set_key_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1385 _internal_set_key_type(value);
1386 // @@protoc_insertion_point(field_set:onnx_torch.MapProto.key_type)
1387}
1388
1389// repeated int64 keys = 3;
1390inline int MapProto::_internal_keys_size() const {
1391 return keys_.size();
1392}
1393inline int MapProto::keys_size() const {
1394 return _internal_keys_size();
1395}
1396inline void MapProto::clear_keys() {
1397 keys_.Clear();
1398}
1399inline ::PROTOBUF_NAMESPACE_ID::int64 MapProto::_internal_keys(int index) const {
1400 return keys_.Get(index);
1401}
1402inline ::PROTOBUF_NAMESPACE_ID::int64 MapProto::keys(int index) const {
1403 // @@protoc_insertion_point(field_get:onnx_torch.MapProto.keys)
1404 return _internal_keys(index);
1405}
1406inline void MapProto::set_keys(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
1407 keys_.Set(index, value);
1408 // @@protoc_insertion_point(field_set:onnx_torch.MapProto.keys)
1409}
1410inline void MapProto::_internal_add_keys(::PROTOBUF_NAMESPACE_ID::int64 value) {
1411 keys_.Add(value);
1412}
1413inline void MapProto::add_keys(::PROTOBUF_NAMESPACE_ID::int64 value) {
1414 _internal_add_keys(value);
1415 // @@protoc_insertion_point(field_add:onnx_torch.MapProto.keys)
1416}
1417inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1418MapProto::_internal_keys() const {
1419 return keys_;
1420}
1421inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1422MapProto::keys() const {
1423 // @@protoc_insertion_point(field_list:onnx_torch.MapProto.keys)
1424 return _internal_keys();
1425}
1426inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1427MapProto::_internal_mutable_keys() {
1428 return &keys_;
1429}
1430inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1431MapProto::mutable_keys() {
1432 // @@protoc_insertion_point(field_mutable_list:onnx_torch.MapProto.keys)
1433 return _internal_mutable_keys();
1434}
1435
1436// repeated bytes string_keys = 4;
1437inline int MapProto::_internal_string_keys_size() const {
1438 return string_keys_.size();
1439}
1440inline int MapProto::string_keys_size() const {
1441 return _internal_string_keys_size();
1442}
1443inline void MapProto::clear_string_keys() {
1444 string_keys_.Clear();
1445}
1446inline std::string* MapProto::add_string_keys() {
1447 // @@protoc_insertion_point(field_add_mutable:onnx_torch.MapProto.string_keys)
1448 return _internal_add_string_keys();
1449}
1450inline const std::string& MapProto::_internal_string_keys(int index) const {
1451 return string_keys_.Get(index);
1452}
1453inline const std::string& MapProto::string_keys(int index) const {
1454 // @@protoc_insertion_point(field_get:onnx_torch.MapProto.string_keys)
1455 return _internal_string_keys(index);
1456}
1457inline std::string* MapProto::mutable_string_keys(int index) {
1458 // @@protoc_insertion_point(field_mutable:onnx_torch.MapProto.string_keys)
1459 return string_keys_.Mutable(index);
1460}
1461inline void MapProto::set_string_keys(int index, const std::string& value) {
1462 // @@protoc_insertion_point(field_set:onnx_torch.MapProto.string_keys)
1463 string_keys_.Mutable(index)->assign(value);
1464}
1465inline void MapProto::set_string_keys(int index, std::string&& value) {
1466 // @@protoc_insertion_point(field_set:onnx_torch.MapProto.string_keys)
1467 string_keys_.Mutable(index)->assign(std::move(value));
1468}
1469inline void MapProto::set_string_keys(int index, const char* value) {
1470 GOOGLE_DCHECK(value != nullptr);
1471 string_keys_.Mutable(index)->assign(value);
1472 // @@protoc_insertion_point(field_set_char:onnx_torch.MapProto.string_keys)
1473}
1474inline void MapProto::set_string_keys(int index, const void* value, size_t size) {
1475 string_keys_.Mutable(index)->assign(
1476 reinterpret_cast<const char*>(value), size);
1477 // @@protoc_insertion_point(field_set_pointer:onnx_torch.MapProto.string_keys)
1478}
1479inline std::string* MapProto::_internal_add_string_keys() {
1480 return string_keys_.Add();
1481}
1482inline void MapProto::add_string_keys(const std::string& value) {
1483 string_keys_.Add()->assign(value);
1484 // @@protoc_insertion_point(field_add:onnx_torch.MapProto.string_keys)
1485}
1486inline void MapProto::add_string_keys(std::string&& value) {
1487 string_keys_.Add(std::move(value));
1488 // @@protoc_insertion_point(field_add:onnx_torch.MapProto.string_keys)
1489}
1490inline void MapProto::add_string_keys(const char* value) {
1491 GOOGLE_DCHECK(value != nullptr);
1492 string_keys_.Add()->assign(value);
1493 // @@protoc_insertion_point(field_add_char:onnx_torch.MapProto.string_keys)
1494}
1495inline void MapProto::add_string_keys(const void* value, size_t size) {
1496 string_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
1497 // @@protoc_insertion_point(field_add_pointer:onnx_torch.MapProto.string_keys)
1498}
1499inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
1500MapProto::string_keys() const {
1501 // @@protoc_insertion_point(field_list:onnx_torch.MapProto.string_keys)
1502 return string_keys_;
1503}
1504inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
1505MapProto::mutable_string_keys() {
1506 // @@protoc_insertion_point(field_mutable_list:onnx_torch.MapProto.string_keys)
1507 return &string_keys_;
1508}
1509
1510// optional .onnx_torch.SequenceProto values = 5;
1511inline bool MapProto::_internal_has_values() const {
1512 bool value = (_has_bits_[0] & 0x00000002u) != 0;
1513 PROTOBUF_ASSUME(!value || values_ != nullptr);
1514 return value;
1515}
1516inline bool MapProto::has_values() const {
1517 return _internal_has_values();
1518}
1519inline void MapProto::clear_values() {
1520 if (values_ != nullptr) values_->Clear();
1521 _has_bits_[0] &= ~0x00000002u;
1522}
1523inline const ::onnx_torch::SequenceProto& MapProto::_internal_values() const {
1524 const ::onnx_torch::SequenceProto* p = values_;
1525 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::SequenceProto*>(
1526 &::onnx_torch::_SequenceProto_default_instance_);
1527}
1528inline const ::onnx_torch::SequenceProto& MapProto::values() const {
1529 // @@protoc_insertion_point(field_get:onnx_torch.MapProto.values)
1530 return _internal_values();
1531}
1532inline void MapProto::unsafe_arena_set_allocated_values(
1533 ::onnx_torch::SequenceProto* values) {
1534 if (GetArena() == nullptr) {
1535 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(values_);
1536 }
1537 values_ = values;
1538 if (values) {
1539 _has_bits_[0] |= 0x00000002u;
1540 } else {
1541 _has_bits_[0] &= ~0x00000002u;
1542 }
1543 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.MapProto.values)
1544}
1545inline ::onnx_torch::SequenceProto* MapProto::release_values() {
1546 _has_bits_[0] &= ~0x00000002u;
1547 ::onnx_torch::SequenceProto* temp = values_;
1548 values_ = nullptr;
1549 if (GetArena() != nullptr) {
1550 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1551 }
1552 return temp;
1553}
1554inline ::onnx_torch::SequenceProto* MapProto::unsafe_arena_release_values() {
1555 // @@protoc_insertion_point(field_release:onnx_torch.MapProto.values)
1556 _has_bits_[0] &= ~0x00000002u;
1557 ::onnx_torch::SequenceProto* temp = values_;
1558 values_ = nullptr;
1559 return temp;
1560}
1561inline ::onnx_torch::SequenceProto* MapProto::_internal_mutable_values() {
1562 _has_bits_[0] |= 0x00000002u;
1563 if (values_ == nullptr) {
1564 auto* p = CreateMaybeMessage<::onnx_torch::SequenceProto>(GetArena());
1565 values_ = p;
1566 }
1567 return values_;
1568}
1569inline ::onnx_torch::SequenceProto* MapProto::mutable_values() {
1570 // @@protoc_insertion_point(field_mutable:onnx_torch.MapProto.values)
1571 return _internal_mutable_values();
1572}
1573inline void MapProto::set_allocated_values(::onnx_torch::SequenceProto* values) {
1574 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
1575 if (message_arena == nullptr) {
1576 delete values_;
1577 }
1578 if (values) {
1579 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1580 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(values);
1581 if (message_arena != submessage_arena) {
1582 values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1583 message_arena, values, submessage_arena);
1584 }
1585 _has_bits_[0] |= 0x00000002u;
1586 } else {
1587 _has_bits_[0] &= ~0x00000002u;
1588 }
1589 values_ = values;
1590 // @@protoc_insertion_point(field_set_allocated:onnx_torch.MapProto.values)
1591}
1592
1593// -------------------------------------------------------------------
1594
1595// OptionalProto
1596
1597// optional string name = 1;
1598inline bool OptionalProto::_internal_has_name() const {
1599 bool value = (_has_bits_[0] & 0x00000001u) != 0;
1600 return value;
1601}
1602inline bool OptionalProto::has_name() const {
1603 return _internal_has_name();
1604}
1605inline void OptionalProto::clear_name() {
1606 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
1607 _has_bits_[0] &= ~0x00000001u;
1608}
1609inline const std::string& OptionalProto::name() const {
1610 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.name)
1611 return _internal_name();
1612}
1613inline void OptionalProto::set_name(const std::string& value) {
1614 _internal_set_name(value);
1615 // @@protoc_insertion_point(field_set:onnx_torch.OptionalProto.name)
1616}
1617inline std::string* OptionalProto::mutable_name() {
1618 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.name)
1619 return _internal_mutable_name();
1620}
1621inline const std::string& OptionalProto::_internal_name() const {
1622 return name_.Get();
1623}
1624inline void OptionalProto::_internal_set_name(const std::string& value) {
1625 _has_bits_[0] |= 0x00000001u;
1626 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
1627}
1628inline void OptionalProto::set_name(std::string&& value) {
1629 _has_bits_[0] |= 0x00000001u;
1630 name_.Set(
1631 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
1632 // @@protoc_insertion_point(field_set_rvalue:onnx_torch.OptionalProto.name)
1633}
1634inline void OptionalProto::set_name(const char* value) {
1635 GOOGLE_DCHECK(value != nullptr);
1636 _has_bits_[0] |= 0x00000001u;
1637 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
1638 GetArena());
1639 // @@protoc_insertion_point(field_set_char:onnx_torch.OptionalProto.name)
1640}
1641inline void OptionalProto::set_name(const char* value,
1642 size_t size) {
1643 _has_bits_[0] |= 0x00000001u;
1644 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
1645 reinterpret_cast<const char*>(value), size), GetArena());
1646 // @@protoc_insertion_point(field_set_pointer:onnx_torch.OptionalProto.name)
1647}
1648inline std::string* OptionalProto::_internal_mutable_name() {
1649 _has_bits_[0] |= 0x00000001u;
1650 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
1651}
1652inline std::string* OptionalProto::release_name() {
1653 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.name)
1654 if (!_internal_has_name()) {
1655 return nullptr;
1656 }
1657 _has_bits_[0] &= ~0x00000001u;
1658 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
1659}
1660inline void OptionalProto::set_allocated_name(std::string* name) {
1661 if (name != nullptr) {
1662 _has_bits_[0] |= 0x00000001u;
1663 } else {
1664 _has_bits_[0] &= ~0x00000001u;
1665 }
1666 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
1667 GetArena());
1668 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.name)
1669}
1670
1671// optional int32 elem_type = 2;
1672inline bool OptionalProto::_internal_has_elem_type() const {
1673 bool value = (_has_bits_[0] & 0x00000040u) != 0;
1674 return value;
1675}
1676inline bool OptionalProto::has_elem_type() const {
1677 return _internal_has_elem_type();
1678}
1679inline void OptionalProto::clear_elem_type() {
1680 elem_type_ = 0;
1681 _has_bits_[0] &= ~0x00000040u;
1682}
1683inline ::PROTOBUF_NAMESPACE_ID::int32 OptionalProto::_internal_elem_type() const {
1684 return elem_type_;
1685}
1686inline ::PROTOBUF_NAMESPACE_ID::int32 OptionalProto::elem_type() const {
1687 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.elem_type)
1688 return _internal_elem_type();
1689}
1690inline void OptionalProto::_internal_set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1691 _has_bits_[0] |= 0x00000040u;
1692 elem_type_ = value;
1693}
1694inline void OptionalProto::set_elem_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
1695 _internal_set_elem_type(value);
1696 // @@protoc_insertion_point(field_set:onnx_torch.OptionalProto.elem_type)
1697}
1698
1699// optional .onnx_torch.TensorProto tensor_value = 3;
1700inline bool OptionalProto::_internal_has_tensor_value() const {
1701 bool value = (_has_bits_[0] & 0x00000002u) != 0;
1702 PROTOBUF_ASSUME(!value || tensor_value_ != nullptr);
1703 return value;
1704}
1705inline bool OptionalProto::has_tensor_value() const {
1706 return _internal_has_tensor_value();
1707}
1708inline const ::onnx_torch::TensorProto& OptionalProto::_internal_tensor_value() const {
1709 const ::onnx_torch::TensorProto* p = tensor_value_;
1710 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::TensorProto*>(
1711 &::onnx_torch::_TensorProto_default_instance_);
1712}
1713inline const ::onnx_torch::TensorProto& OptionalProto::tensor_value() const {
1714 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.tensor_value)
1715 return _internal_tensor_value();
1716}
1717inline void OptionalProto::unsafe_arena_set_allocated_tensor_value(
1718 ::onnx_torch::TensorProto* tensor_value) {
1719 if (GetArena() == nullptr) {
1720 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_value_);
1721 }
1722 tensor_value_ = tensor_value;
1723 if (tensor_value) {
1724 _has_bits_[0] |= 0x00000002u;
1725 } else {
1726 _has_bits_[0] &= ~0x00000002u;
1727 }
1728 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.OptionalProto.tensor_value)
1729}
1730inline ::onnx_torch::TensorProto* OptionalProto::release_tensor_value() {
1731 _has_bits_[0] &= ~0x00000002u;
1732 ::onnx_torch::TensorProto* temp = tensor_value_;
1733 tensor_value_ = nullptr;
1734 if (GetArena() != nullptr) {
1735 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1736 }
1737 return temp;
1738}
1739inline ::onnx_torch::TensorProto* OptionalProto::unsafe_arena_release_tensor_value() {
1740 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.tensor_value)
1741 _has_bits_[0] &= ~0x00000002u;
1742 ::onnx_torch::TensorProto* temp = tensor_value_;
1743 tensor_value_ = nullptr;
1744 return temp;
1745}
1746inline ::onnx_torch::TensorProto* OptionalProto::_internal_mutable_tensor_value() {
1747 _has_bits_[0] |= 0x00000002u;
1748 if (tensor_value_ == nullptr) {
1749 auto* p = CreateMaybeMessage<::onnx_torch::TensorProto>(GetArena());
1750 tensor_value_ = p;
1751 }
1752 return tensor_value_;
1753}
1754inline ::onnx_torch::TensorProto* OptionalProto::mutable_tensor_value() {
1755 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.tensor_value)
1756 return _internal_mutable_tensor_value();
1757}
1758inline void OptionalProto::set_allocated_tensor_value(::onnx_torch::TensorProto* tensor_value) {
1759 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
1760 if (message_arena == nullptr) {
1761 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_value_);
1762 }
1763 if (tensor_value) {
1764 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1765 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_value)->GetArena();
1766 if (message_arena != submessage_arena) {
1767 tensor_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1768 message_arena, tensor_value, submessage_arena);
1769 }
1770 _has_bits_[0] |= 0x00000002u;
1771 } else {
1772 _has_bits_[0] &= ~0x00000002u;
1773 }
1774 tensor_value_ = tensor_value;
1775 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.tensor_value)
1776}
1777
1778// optional .onnx_torch.SparseTensorProto sparse_tensor_value = 4;
1779inline bool OptionalProto::_internal_has_sparse_tensor_value() const {
1780 bool value = (_has_bits_[0] & 0x00000004u) != 0;
1781 PROTOBUF_ASSUME(!value || sparse_tensor_value_ != nullptr);
1782 return value;
1783}
1784inline bool OptionalProto::has_sparse_tensor_value() const {
1785 return _internal_has_sparse_tensor_value();
1786}
1787inline const ::onnx_torch::SparseTensorProto& OptionalProto::_internal_sparse_tensor_value() const {
1788 const ::onnx_torch::SparseTensorProto* p = sparse_tensor_value_;
1789 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::SparseTensorProto*>(
1790 &::onnx_torch::_SparseTensorProto_default_instance_);
1791}
1792inline const ::onnx_torch::SparseTensorProto& OptionalProto::sparse_tensor_value() const {
1793 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.sparse_tensor_value)
1794 return _internal_sparse_tensor_value();
1795}
1796inline void OptionalProto::unsafe_arena_set_allocated_sparse_tensor_value(
1797 ::onnx_torch::SparseTensorProto* sparse_tensor_value) {
1798 if (GetArena() == nullptr) {
1799 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_value_);
1800 }
1801 sparse_tensor_value_ = sparse_tensor_value;
1802 if (sparse_tensor_value) {
1803 _has_bits_[0] |= 0x00000004u;
1804 } else {
1805 _has_bits_[0] &= ~0x00000004u;
1806 }
1807 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.OptionalProto.sparse_tensor_value)
1808}
1809inline ::onnx_torch::SparseTensorProto* OptionalProto::release_sparse_tensor_value() {
1810 _has_bits_[0] &= ~0x00000004u;
1811 ::onnx_torch::SparseTensorProto* temp = sparse_tensor_value_;
1812 sparse_tensor_value_ = nullptr;
1813 if (GetArena() != nullptr) {
1814 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1815 }
1816 return temp;
1817}
1818inline ::onnx_torch::SparseTensorProto* OptionalProto::unsafe_arena_release_sparse_tensor_value() {
1819 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.sparse_tensor_value)
1820 _has_bits_[0] &= ~0x00000004u;
1821 ::onnx_torch::SparseTensorProto* temp = sparse_tensor_value_;
1822 sparse_tensor_value_ = nullptr;
1823 return temp;
1824}
1825inline ::onnx_torch::SparseTensorProto* OptionalProto::_internal_mutable_sparse_tensor_value() {
1826 _has_bits_[0] |= 0x00000004u;
1827 if (sparse_tensor_value_ == nullptr) {
1828 auto* p = CreateMaybeMessage<::onnx_torch::SparseTensorProto>(GetArena());
1829 sparse_tensor_value_ = p;
1830 }
1831 return sparse_tensor_value_;
1832}
1833inline ::onnx_torch::SparseTensorProto* OptionalProto::mutable_sparse_tensor_value() {
1834 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.sparse_tensor_value)
1835 return _internal_mutable_sparse_tensor_value();
1836}
1837inline void OptionalProto::set_allocated_sparse_tensor_value(::onnx_torch::SparseTensorProto* sparse_tensor_value) {
1838 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
1839 if (message_arena == nullptr) {
1840 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_value_);
1841 }
1842 if (sparse_tensor_value) {
1843 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1844 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sparse_tensor_value)->GetArena();
1845 if (message_arena != submessage_arena) {
1846 sparse_tensor_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1847 message_arena, sparse_tensor_value, submessage_arena);
1848 }
1849 _has_bits_[0] |= 0x00000004u;
1850 } else {
1851 _has_bits_[0] &= ~0x00000004u;
1852 }
1853 sparse_tensor_value_ = sparse_tensor_value;
1854 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.sparse_tensor_value)
1855}
1856
1857// optional .onnx_torch.SequenceProto sequence_value = 5;
1858inline bool OptionalProto::_internal_has_sequence_value() const {
1859 bool value = (_has_bits_[0] & 0x00000008u) != 0;
1860 PROTOBUF_ASSUME(!value || sequence_value_ != nullptr);
1861 return value;
1862}
1863inline bool OptionalProto::has_sequence_value() const {
1864 return _internal_has_sequence_value();
1865}
1866inline void OptionalProto::clear_sequence_value() {
1867 if (sequence_value_ != nullptr) sequence_value_->Clear();
1868 _has_bits_[0] &= ~0x00000008u;
1869}
1870inline const ::onnx_torch::SequenceProto& OptionalProto::_internal_sequence_value() const {
1871 const ::onnx_torch::SequenceProto* p = sequence_value_;
1872 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::SequenceProto*>(
1873 &::onnx_torch::_SequenceProto_default_instance_);
1874}
1875inline const ::onnx_torch::SequenceProto& OptionalProto::sequence_value() const {
1876 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.sequence_value)
1877 return _internal_sequence_value();
1878}
1879inline void OptionalProto::unsafe_arena_set_allocated_sequence_value(
1880 ::onnx_torch::SequenceProto* sequence_value) {
1881 if (GetArena() == nullptr) {
1882 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sequence_value_);
1883 }
1884 sequence_value_ = sequence_value;
1885 if (sequence_value) {
1886 _has_bits_[0] |= 0x00000008u;
1887 } else {
1888 _has_bits_[0] &= ~0x00000008u;
1889 }
1890 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.OptionalProto.sequence_value)
1891}
1892inline ::onnx_torch::SequenceProto* OptionalProto::release_sequence_value() {
1893 _has_bits_[0] &= ~0x00000008u;
1894 ::onnx_torch::SequenceProto* temp = sequence_value_;
1895 sequence_value_ = nullptr;
1896 if (GetArena() != nullptr) {
1897 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1898 }
1899 return temp;
1900}
1901inline ::onnx_torch::SequenceProto* OptionalProto::unsafe_arena_release_sequence_value() {
1902 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.sequence_value)
1903 _has_bits_[0] &= ~0x00000008u;
1904 ::onnx_torch::SequenceProto* temp = sequence_value_;
1905 sequence_value_ = nullptr;
1906 return temp;
1907}
1908inline ::onnx_torch::SequenceProto* OptionalProto::_internal_mutable_sequence_value() {
1909 _has_bits_[0] |= 0x00000008u;
1910 if (sequence_value_ == nullptr) {
1911 auto* p = CreateMaybeMessage<::onnx_torch::SequenceProto>(GetArena());
1912 sequence_value_ = p;
1913 }
1914 return sequence_value_;
1915}
1916inline ::onnx_torch::SequenceProto* OptionalProto::mutable_sequence_value() {
1917 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.sequence_value)
1918 return _internal_mutable_sequence_value();
1919}
1920inline void OptionalProto::set_allocated_sequence_value(::onnx_torch::SequenceProto* sequence_value) {
1921 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
1922 if (message_arena == nullptr) {
1923 delete sequence_value_;
1924 }
1925 if (sequence_value) {
1926 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1927 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sequence_value);
1928 if (message_arena != submessage_arena) {
1929 sequence_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1930 message_arena, sequence_value, submessage_arena);
1931 }
1932 _has_bits_[0] |= 0x00000008u;
1933 } else {
1934 _has_bits_[0] &= ~0x00000008u;
1935 }
1936 sequence_value_ = sequence_value;
1937 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.sequence_value)
1938}
1939
1940// optional .onnx_torch.MapProto map_value = 6;
1941inline bool OptionalProto::_internal_has_map_value() const {
1942 bool value = (_has_bits_[0] & 0x00000010u) != 0;
1943 PROTOBUF_ASSUME(!value || map_value_ != nullptr);
1944 return value;
1945}
1946inline bool OptionalProto::has_map_value() const {
1947 return _internal_has_map_value();
1948}
1949inline void OptionalProto::clear_map_value() {
1950 if (map_value_ != nullptr) map_value_->Clear();
1951 _has_bits_[0] &= ~0x00000010u;
1952}
1953inline const ::onnx_torch::MapProto& OptionalProto::_internal_map_value() const {
1954 const ::onnx_torch::MapProto* p = map_value_;
1955 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::MapProto*>(
1956 &::onnx_torch::_MapProto_default_instance_);
1957}
1958inline const ::onnx_torch::MapProto& OptionalProto::map_value() const {
1959 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.map_value)
1960 return _internal_map_value();
1961}
1962inline void OptionalProto::unsafe_arena_set_allocated_map_value(
1963 ::onnx_torch::MapProto* map_value) {
1964 if (GetArena() == nullptr) {
1965 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_value_);
1966 }
1967 map_value_ = map_value;
1968 if (map_value) {
1969 _has_bits_[0] |= 0x00000010u;
1970 } else {
1971 _has_bits_[0] &= ~0x00000010u;
1972 }
1973 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.OptionalProto.map_value)
1974}
1975inline ::onnx_torch::MapProto* OptionalProto::release_map_value() {
1976 _has_bits_[0] &= ~0x00000010u;
1977 ::onnx_torch::MapProto* temp = map_value_;
1978 map_value_ = nullptr;
1979 if (GetArena() != nullptr) {
1980 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1981 }
1982 return temp;
1983}
1984inline ::onnx_torch::MapProto* OptionalProto::unsafe_arena_release_map_value() {
1985 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.map_value)
1986 _has_bits_[0] &= ~0x00000010u;
1987 ::onnx_torch::MapProto* temp = map_value_;
1988 map_value_ = nullptr;
1989 return temp;
1990}
1991inline ::onnx_torch::MapProto* OptionalProto::_internal_mutable_map_value() {
1992 _has_bits_[0] |= 0x00000010u;
1993 if (map_value_ == nullptr) {
1994 auto* p = CreateMaybeMessage<::onnx_torch::MapProto>(GetArena());
1995 map_value_ = p;
1996 }
1997 return map_value_;
1998}
1999inline ::onnx_torch::MapProto* OptionalProto::mutable_map_value() {
2000 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.map_value)
2001 return _internal_mutable_map_value();
2002}
2003inline void OptionalProto::set_allocated_map_value(::onnx_torch::MapProto* map_value) {
2004 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
2005 if (message_arena == nullptr) {
2006 delete map_value_;
2007 }
2008 if (map_value) {
2009 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2010 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_value);
2011 if (message_arena != submessage_arena) {
2012 map_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2013 message_arena, map_value, submessage_arena);
2014 }
2015 _has_bits_[0] |= 0x00000010u;
2016 } else {
2017 _has_bits_[0] &= ~0x00000010u;
2018 }
2019 map_value_ = map_value;
2020 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.map_value)
2021}
2022
2023// optional .onnx_torch.OptionalProto optional_value = 7;
2024inline bool OptionalProto::_internal_has_optional_value() const {
2025 bool value = (_has_bits_[0] & 0x00000020u) != 0;
2026 PROTOBUF_ASSUME(!value || optional_value_ != nullptr);
2027 return value;
2028}
2029inline bool OptionalProto::has_optional_value() const {
2030 return _internal_has_optional_value();
2031}
2032inline void OptionalProto::clear_optional_value() {
2033 if (optional_value_ != nullptr) optional_value_->Clear();
2034 _has_bits_[0] &= ~0x00000020u;
2035}
2036inline const ::onnx_torch::OptionalProto& OptionalProto::_internal_optional_value() const {
2037 const ::onnx_torch::OptionalProto* p = optional_value_;
2038 return p != nullptr ? *p : *reinterpret_cast<const ::onnx_torch::OptionalProto*>(
2039 &::onnx_torch::_OptionalProto_default_instance_);
2040}
2041inline const ::onnx_torch::OptionalProto& OptionalProto::optional_value() const {
2042 // @@protoc_insertion_point(field_get:onnx_torch.OptionalProto.optional_value)
2043 return _internal_optional_value();
2044}
2045inline void OptionalProto::unsafe_arena_set_allocated_optional_value(
2046 ::onnx_torch::OptionalProto* optional_value) {
2047 if (GetArena() == nullptr) {
2048 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_value_);
2049 }
2050 optional_value_ = optional_value;
2051 if (optional_value) {
2052 _has_bits_[0] |= 0x00000020u;
2053 } else {
2054 _has_bits_[0] &= ~0x00000020u;
2055 }
2056 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx_torch.OptionalProto.optional_value)
2057}
2058inline ::onnx_torch::OptionalProto* OptionalProto::release_optional_value() {
2059 _has_bits_[0] &= ~0x00000020u;
2060 ::onnx_torch::OptionalProto* temp = optional_value_;
2061 optional_value_ = nullptr;
2062 if (GetArena() != nullptr) {
2063 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2064 }
2065 return temp;
2066}
2067inline ::onnx_torch::OptionalProto* OptionalProto::unsafe_arena_release_optional_value() {
2068 // @@protoc_insertion_point(field_release:onnx_torch.OptionalProto.optional_value)
2069 _has_bits_[0] &= ~0x00000020u;
2070 ::onnx_torch::OptionalProto* temp = optional_value_;
2071 optional_value_ = nullptr;
2072 return temp;
2073}
2074inline ::onnx_torch::OptionalProto* OptionalProto::_internal_mutable_optional_value() {
2075 _has_bits_[0] |= 0x00000020u;
2076 if (optional_value_ == nullptr) {
2077 auto* p = CreateMaybeMessage<::onnx_torch::OptionalProto>(GetArena());
2078 optional_value_ = p;
2079 }
2080 return optional_value_;
2081}
2082inline ::onnx_torch::OptionalProto* OptionalProto::mutable_optional_value() {
2083 // @@protoc_insertion_point(field_mutable:onnx_torch.OptionalProto.optional_value)
2084 return _internal_mutable_optional_value();
2085}
2086inline void OptionalProto::set_allocated_optional_value(::onnx_torch::OptionalProto* optional_value) {
2087 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
2088 if (message_arena == nullptr) {
2089 delete optional_value_;
2090 }
2091 if (optional_value) {
2092 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2093 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(optional_value);
2094 if (message_arena != submessage_arena) {
2095 optional_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2096 message_arena, optional_value, submessage_arena);
2097 }
2098 _has_bits_[0] |= 0x00000020u;
2099 } else {
2100 _has_bits_[0] &= ~0x00000020u;
2101 }
2102 optional_value_ = optional_value;
2103 // @@protoc_insertion_point(field_set_allocated:onnx_torch.OptionalProto.optional_value)
2104}
2105
2106#ifdef __GNUC__
2107 #pragma GCC diagnostic pop
2108#endif // __GNUC__
2109// -------------------------------------------------------------------
2110
2111// -------------------------------------------------------------------
2112
2113
2114// @@protoc_insertion_point(namespace_scope)
2115
2116} // namespace onnx_torch
2117
2118PROTOBUF_NAMESPACE_OPEN
2119
2120template <> struct is_proto_enum< ::onnx_torch::SequenceProto_DataType> : ::std::true_type {};
2121template <>
2122inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::SequenceProto_DataType>() {
2123 return ::onnx_torch::SequenceProto_DataType_descriptor();
2124}
2125template <> struct is_proto_enum< ::onnx_torch::OptionalProto_DataType> : ::std::true_type {};
2126template <>
2127inline const EnumDescriptor* GetEnumDescriptor< ::onnx_torch::OptionalProto_DataType>() {
2128 return ::onnx_torch::OptionalProto_DataType_descriptor();
2129}
2130
2131PROTOBUF_NAMESPACE_CLOSE
2132
2133// @@protoc_insertion_point(global_scope)
2134
2135#include <google/protobuf/port_undef.inc>
2136#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_onnx_2fonnx_2ddata_5fonnx_5ftorch_2eproto
2137