1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/framework/op_def.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include "tensorflow/core/framework/attr_value.pb.h"
33 #include "tensorflow/core/framework/full_type.pb.h"
34 #include "tensorflow/core/framework/resource_handle.pb.h"
35 #include "tensorflow/core/framework/types.pb.h"
36 // @@protoc_insertion_point(includes)
37 #include <google/protobuf/port_def.inc>
38 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
39 PROTOBUF_NAMESPACE_OPEN
40 namespace internal {
41 class AnyMetadata;
42 } // namespace internal
43 PROTOBUF_NAMESPACE_CLOSE
44
45 // Internal implementation detail -- do not use these members.
46 struct TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto {
47 static const ::uint32_t offsets[];
48 };
49 namespace tensorflow {
50 class OpDef;
51 struct OpDefDefaultTypeInternal;
52 extern OpDefDefaultTypeInternal _OpDef_default_instance_;
53 class OpDef_ArgDef;
54 struct OpDef_ArgDefDefaultTypeInternal;
55 extern OpDef_ArgDefDefaultTypeInternal _OpDef_ArgDef_default_instance_;
56 class OpDef_AttrDef;
57 struct OpDef_AttrDefDefaultTypeInternal;
58 extern OpDef_AttrDefDefaultTypeInternal _OpDef_AttrDef_default_instance_;
59 class OpDeprecation;
60 struct OpDeprecationDefaultTypeInternal;
61 extern OpDeprecationDefaultTypeInternal _OpDeprecation_default_instance_;
62 class OpList;
63 struct OpListDefaultTypeInternal;
64 extern OpListDefaultTypeInternal _OpList_default_instance_;
65 } // namespace tensorflow
66 PROTOBUF_NAMESPACE_OPEN
67 template<> ::tensorflow::OpDef* Arena::CreateMaybeMessage<::tensorflow::OpDef>(Arena*);
68 template<> ::tensorflow::OpDef_ArgDef* Arena::CreateMaybeMessage<::tensorflow::OpDef_ArgDef>(Arena*);
69 template<> ::tensorflow::OpDef_AttrDef* Arena::CreateMaybeMessage<::tensorflow::OpDef_AttrDef>(Arena*);
70 template<> ::tensorflow::OpDeprecation* Arena::CreateMaybeMessage<::tensorflow::OpDeprecation>(Arena*);
71 template<> ::tensorflow::OpList* Arena::CreateMaybeMessage<::tensorflow::OpList>(Arena*);
72 PROTOBUF_NAMESPACE_CLOSE
73 namespace tensorflow {
74
75 // ===================================================================
76
77 class OpDef_ArgDef final :
78 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.ArgDef) */ {
79 public:
OpDef_ArgDef()80 inline OpDef_ArgDef() : OpDef_ArgDef(nullptr) {}
81 ~OpDef_ArgDef() override;
82 explicit PROTOBUF_CONSTEXPR OpDef_ArgDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
83
84 OpDef_ArgDef(const OpDef_ArgDef& from);
OpDef_ArgDef(OpDef_ArgDef && from)85 OpDef_ArgDef(OpDef_ArgDef&& from) noexcept
86 : OpDef_ArgDef() {
87 *this = ::std::move(from);
88 }
89
90 inline OpDef_ArgDef& operator=(const OpDef_ArgDef& from) {
91 if (this == &from) return *this;
92 CopyFrom(from);
93 return *this;
94 }
95 inline OpDef_ArgDef& operator=(OpDef_ArgDef&& from) noexcept {
96 if (this == &from) return *this;
97 if (GetOwningArena() == from.GetOwningArena()
98 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
99 && GetOwningArena() != nullptr
100 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
101 ) {
102 InternalSwap(&from);
103 } else {
104 CopyFrom(from);
105 }
106 return *this;
107 }
108
default_instance()109 static const OpDef_ArgDef& default_instance() {
110 return *internal_default_instance();
111 }
internal_default_instance()112 static inline const OpDef_ArgDef* internal_default_instance() {
113 return reinterpret_cast<const OpDef_ArgDef*>(
114 &_OpDef_ArgDef_default_instance_);
115 }
116 static constexpr int kIndexInFileMessages =
117 0;
118
swap(OpDef_ArgDef & a,OpDef_ArgDef & b)119 friend void swap(OpDef_ArgDef& a, OpDef_ArgDef& b) {
120 a.Swap(&b);
121 }
Swap(OpDef_ArgDef * other)122 inline void Swap(OpDef_ArgDef* other) {
123 if (other == this) return;
124 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
125 if (GetOwningArena() != nullptr &&
126 GetOwningArena() == other->GetOwningArena()) {
127 #else // PROTOBUF_FORCE_COPY_IN_SWAP
128 if (GetOwningArena() == other->GetOwningArena()) {
129 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
130 InternalSwap(other);
131 } else {
132 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
133 }
134 }
135 void UnsafeArenaSwap(OpDef_ArgDef* other) {
136 if (other == this) return;
137 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
138 InternalSwap(other);
139 }
140
141 // implements Message ----------------------------------------------
142
143 OpDef_ArgDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
144 return CreateMaybeMessage<OpDef_ArgDef>(arena);
145 }
146 OpDef_ArgDef* New() const {
147 return New(nullptr);
148 }
149 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
150 void CopyFrom(const OpDef_ArgDef& from);
151 void MergeFrom(const OpDef_ArgDef& from);
152 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
153 bool IsInitialized() const final;
154
155 size_t ByteSizeLong() const final;
156 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
157 ::uint8_t* _InternalSerialize(
158 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
159 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
160
161 private:
162 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
163 void SharedDtor();
164 void SetCachedSize(int size) const;
165 void InternalSwap(OpDef_ArgDef* other);
166
167 private:
168 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
169 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
170 return "tensorflow.OpDef.ArgDef";
171 }
172 protected:
173 explicit OpDef_ArgDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
174 bool is_message_owned = false);
175 public:
176
177 std::string GetTypeName() const final;
178
179 // nested types ----------------------------------------------------
180
181 // accessors -------------------------------------------------------
182
183 enum : int {
184 kHandleDataFieldNumber = 7,
185 kNameFieldNumber = 1,
186 kDescriptionFieldNumber = 2,
187 kTypeAttrFieldNumber = 4,
188 kNumberAttrFieldNumber = 5,
189 kTypeListAttrFieldNumber = 6,
190 kExperimentalFullTypeFieldNumber = 17,
191 kTypeFieldNumber = 3,
192 kIsRefFieldNumber = 16,
193 };
194 // repeated .tensorflow.ResourceHandleProto.DtypeAndShape handle_data = 7;
195 int handle_data_size() const;
196 private:
197 int _internal_handle_data_size() const;
198 public:
199 void clear_handle_data();
200 ::tensorflow::ResourceHandleProto_DtypeAndShape* mutable_handle_data(int index);
201 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
202 mutable_handle_data();
203 private:
204 const ::tensorflow::ResourceHandleProto_DtypeAndShape& _internal_handle_data(int index) const;
205 ::tensorflow::ResourceHandleProto_DtypeAndShape* _internal_add_handle_data();
206 public:
207 const ::tensorflow::ResourceHandleProto_DtypeAndShape& handle_data(int index) const;
208 ::tensorflow::ResourceHandleProto_DtypeAndShape* add_handle_data();
209 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
210 handle_data() const;
211
212 // string name = 1;
213 void clear_name();
214 const std::string& name() const;
215 template <typename ArgT0 = const std::string&, typename... ArgT>
216 void set_name(ArgT0&& arg0, ArgT... args);
217 std::string* mutable_name();
218 PROTOBUF_NODISCARD std::string* release_name();
219 void set_allocated_name(std::string* name);
220 private:
221 const std::string& _internal_name() const;
222 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
223 std::string* _internal_mutable_name();
224 public:
225
226 // string description = 2;
227 void clear_description();
228 const std::string& description() const;
229 template <typename ArgT0 = const std::string&, typename... ArgT>
230 void set_description(ArgT0&& arg0, ArgT... args);
231 std::string* mutable_description();
232 PROTOBUF_NODISCARD std::string* release_description();
233 void set_allocated_description(std::string* description);
234 private:
235 const std::string& _internal_description() const;
236 inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
237 std::string* _internal_mutable_description();
238 public:
239
240 // string type_attr = 4;
241 void clear_type_attr();
242 const std::string& type_attr() const;
243 template <typename ArgT0 = const std::string&, typename... ArgT>
244 void set_type_attr(ArgT0&& arg0, ArgT... args);
245 std::string* mutable_type_attr();
246 PROTOBUF_NODISCARD std::string* release_type_attr();
247 void set_allocated_type_attr(std::string* type_attr);
248 private:
249 const std::string& _internal_type_attr() const;
250 inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_attr(const std::string& value);
251 std::string* _internal_mutable_type_attr();
252 public:
253
254 // string number_attr = 5;
255 void clear_number_attr();
256 const std::string& number_attr() const;
257 template <typename ArgT0 = const std::string&, typename... ArgT>
258 void set_number_attr(ArgT0&& arg0, ArgT... args);
259 std::string* mutable_number_attr();
260 PROTOBUF_NODISCARD std::string* release_number_attr();
261 void set_allocated_number_attr(std::string* number_attr);
262 private:
263 const std::string& _internal_number_attr() const;
264 inline PROTOBUF_ALWAYS_INLINE void _internal_set_number_attr(const std::string& value);
265 std::string* _internal_mutable_number_attr();
266 public:
267
268 // string type_list_attr = 6;
269 void clear_type_list_attr();
270 const std::string& type_list_attr() const;
271 template <typename ArgT0 = const std::string&, typename... ArgT>
272 void set_type_list_attr(ArgT0&& arg0, ArgT... args);
273 std::string* mutable_type_list_attr();
274 PROTOBUF_NODISCARD std::string* release_type_list_attr();
275 void set_allocated_type_list_attr(std::string* type_list_attr);
276 private:
277 const std::string& _internal_type_list_attr() const;
278 inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_list_attr(const std::string& value);
279 std::string* _internal_mutable_type_list_attr();
280 public:
281
282 // .tensorflow.FullTypeDef experimental_full_type = 17;
283 bool has_experimental_full_type() const;
284 private:
285 bool _internal_has_experimental_full_type() const;
286 public:
287 void clear_experimental_full_type();
288 const ::tensorflow::FullTypeDef& experimental_full_type() const;
289 PROTOBUF_NODISCARD ::tensorflow::FullTypeDef* release_experimental_full_type();
290 ::tensorflow::FullTypeDef* mutable_experimental_full_type();
291 void set_allocated_experimental_full_type(::tensorflow::FullTypeDef* experimental_full_type);
292 private:
293 const ::tensorflow::FullTypeDef& _internal_experimental_full_type() const;
294 ::tensorflow::FullTypeDef* _internal_mutable_experimental_full_type();
295 public:
296 void unsafe_arena_set_allocated_experimental_full_type(
297 ::tensorflow::FullTypeDef* experimental_full_type);
298 ::tensorflow::FullTypeDef* unsafe_arena_release_experimental_full_type();
299
300 // .tensorflow.DataType type = 3;
301 void clear_type();
302 ::tensorflow::DataType type() const;
303 void set_type(::tensorflow::DataType value);
304 private:
305 ::tensorflow::DataType _internal_type() const;
306 void _internal_set_type(::tensorflow::DataType value);
307 public:
308
309 // bool is_ref = 16;
310 void clear_is_ref();
311 bool is_ref() const;
312 void set_is_ref(bool value);
313 private:
314 bool _internal_is_ref() const;
315 void _internal_set_is_ref(bool value);
316 public:
317
318 // @@protoc_insertion_point(class_scope:tensorflow.OpDef.ArgDef)
319 private:
320 class _Internal;
321
322 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
323 typedef void InternalArenaConstructable_;
324 typedef void DestructorSkippable_;
325 struct Impl_ {
326 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape > handle_data_;
327 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
328 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
329 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_attr_;
330 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr number_attr_;
331 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_list_attr_;
332 ::tensorflow::FullTypeDef* experimental_full_type_;
333 int type_;
334 bool is_ref_;
335 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
336 };
337 union { Impl_ _impl_; };
338 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
339 };
340 // -------------------------------------------------------------------
341
342 class OpDef_AttrDef final :
343 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpDef.AttrDef) */ {
344 public:
OpDef_AttrDef()345 inline OpDef_AttrDef() : OpDef_AttrDef(nullptr) {}
346 ~OpDef_AttrDef() override;
347 explicit PROTOBUF_CONSTEXPR OpDef_AttrDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
348
349 OpDef_AttrDef(const OpDef_AttrDef& from);
OpDef_AttrDef(OpDef_AttrDef && from)350 OpDef_AttrDef(OpDef_AttrDef&& from) noexcept
351 : OpDef_AttrDef() {
352 *this = ::std::move(from);
353 }
354
355 inline OpDef_AttrDef& operator=(const OpDef_AttrDef& from) {
356 if (this == &from) return *this;
357 CopyFrom(from);
358 return *this;
359 }
360 inline OpDef_AttrDef& operator=(OpDef_AttrDef&& from) noexcept {
361 if (this == &from) return *this;
362 if (GetOwningArena() == from.GetOwningArena()
363 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
364 && GetOwningArena() != nullptr
365 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
366 ) {
367 InternalSwap(&from);
368 } else {
369 CopyFrom(from);
370 }
371 return *this;
372 }
373
default_instance()374 static const OpDef_AttrDef& default_instance() {
375 return *internal_default_instance();
376 }
internal_default_instance()377 static inline const OpDef_AttrDef* internal_default_instance() {
378 return reinterpret_cast<const OpDef_AttrDef*>(
379 &_OpDef_AttrDef_default_instance_);
380 }
381 static constexpr int kIndexInFileMessages =
382 1;
383
swap(OpDef_AttrDef & a,OpDef_AttrDef & b)384 friend void swap(OpDef_AttrDef& a, OpDef_AttrDef& b) {
385 a.Swap(&b);
386 }
Swap(OpDef_AttrDef * other)387 inline void Swap(OpDef_AttrDef* other) {
388 if (other == this) return;
389 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
390 if (GetOwningArena() != nullptr &&
391 GetOwningArena() == other->GetOwningArena()) {
392 #else // PROTOBUF_FORCE_COPY_IN_SWAP
393 if (GetOwningArena() == other->GetOwningArena()) {
394 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
395 InternalSwap(other);
396 } else {
397 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
398 }
399 }
400 void UnsafeArenaSwap(OpDef_AttrDef* other) {
401 if (other == this) return;
402 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
403 InternalSwap(other);
404 }
405
406 // implements Message ----------------------------------------------
407
408 OpDef_AttrDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
409 return CreateMaybeMessage<OpDef_AttrDef>(arena);
410 }
411 OpDef_AttrDef* New() const {
412 return New(nullptr);
413 }
414 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
415 void CopyFrom(const OpDef_AttrDef& from);
416 void MergeFrom(const OpDef_AttrDef& from);
417 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
418 bool IsInitialized() const final;
419
420 size_t ByteSizeLong() const final;
421 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
422 ::uint8_t* _InternalSerialize(
423 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
424 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
425
426 private:
427 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
428 void SharedDtor();
429 void SetCachedSize(int size) const;
430 void InternalSwap(OpDef_AttrDef* other);
431
432 private:
433 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
434 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
435 return "tensorflow.OpDef.AttrDef";
436 }
437 protected:
438 explicit OpDef_AttrDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
439 bool is_message_owned = false);
440 public:
441
442 std::string GetTypeName() const final;
443
444 // nested types ----------------------------------------------------
445
446 // accessors -------------------------------------------------------
447
448 enum : int {
449 kNameFieldNumber = 1,
450 kTypeFieldNumber = 2,
451 kDescriptionFieldNumber = 4,
452 kDefaultValueFieldNumber = 3,
453 kAllowedValuesFieldNumber = 7,
454 kMinimumFieldNumber = 6,
455 kHasMinimumFieldNumber = 5,
456 };
457 // string name = 1;
458 void clear_name();
459 const std::string& name() const;
460 template <typename ArgT0 = const std::string&, typename... ArgT>
461 void set_name(ArgT0&& arg0, ArgT... args);
462 std::string* mutable_name();
463 PROTOBUF_NODISCARD std::string* release_name();
464 void set_allocated_name(std::string* name);
465 private:
466 const std::string& _internal_name() const;
467 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
468 std::string* _internal_mutable_name();
469 public:
470
471 // string type = 2;
472 void clear_type();
473 const std::string& type() const;
474 template <typename ArgT0 = const std::string&, typename... ArgT>
475 void set_type(ArgT0&& arg0, ArgT... args);
476 std::string* mutable_type();
477 PROTOBUF_NODISCARD std::string* release_type();
478 void set_allocated_type(std::string* type);
479 private:
480 const std::string& _internal_type() const;
481 inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
482 std::string* _internal_mutable_type();
483 public:
484
485 // string description = 4;
486 void clear_description();
487 const std::string& description() const;
488 template <typename ArgT0 = const std::string&, typename... ArgT>
489 void set_description(ArgT0&& arg0, ArgT... args);
490 std::string* mutable_description();
491 PROTOBUF_NODISCARD std::string* release_description();
492 void set_allocated_description(std::string* description);
493 private:
494 const std::string& _internal_description() const;
495 inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
496 std::string* _internal_mutable_description();
497 public:
498
499 // .tensorflow.AttrValue default_value = 3;
500 bool has_default_value() const;
501 private:
502 bool _internal_has_default_value() const;
503 public:
504 void clear_default_value();
505 const ::tensorflow::AttrValue& default_value() const;
506 PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_default_value();
507 ::tensorflow::AttrValue* mutable_default_value();
508 void set_allocated_default_value(::tensorflow::AttrValue* default_value);
509 private:
510 const ::tensorflow::AttrValue& _internal_default_value() const;
511 ::tensorflow::AttrValue* _internal_mutable_default_value();
512 public:
513 void unsafe_arena_set_allocated_default_value(
514 ::tensorflow::AttrValue* default_value);
515 ::tensorflow::AttrValue* unsafe_arena_release_default_value();
516
517 // .tensorflow.AttrValue allowed_values = 7;
518 bool has_allowed_values() const;
519 private:
520 bool _internal_has_allowed_values() const;
521 public:
522 void clear_allowed_values();
523 const ::tensorflow::AttrValue& allowed_values() const;
524 PROTOBUF_NODISCARD ::tensorflow::AttrValue* release_allowed_values();
525 ::tensorflow::AttrValue* mutable_allowed_values();
526 void set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values);
527 private:
528 const ::tensorflow::AttrValue& _internal_allowed_values() const;
529 ::tensorflow::AttrValue* _internal_mutable_allowed_values();
530 public:
531 void unsafe_arena_set_allocated_allowed_values(
532 ::tensorflow::AttrValue* allowed_values);
533 ::tensorflow::AttrValue* unsafe_arena_release_allowed_values();
534
535 // int64 minimum = 6;
536 void clear_minimum();
537 ::int64_t minimum() const;
538 void set_minimum(::int64_t value);
539 private:
540 ::int64_t _internal_minimum() const;
541 void _internal_set_minimum(::int64_t value);
542 public:
543
544 // bool has_minimum = 5;
545 void clear_has_minimum();
546 bool has_minimum() const;
547 void set_has_minimum(bool value);
548 private:
549 bool _internal_has_minimum() const;
550 void _internal_set_has_minimum(bool value);
551 public:
552
553 // @@protoc_insertion_point(class_scope:tensorflow.OpDef.AttrDef)
554 private:
555 class _Internal;
556
557 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
558 typedef void InternalArenaConstructable_;
559 typedef void DestructorSkippable_;
560 struct Impl_ {
561 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
562 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
563 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
564 ::tensorflow::AttrValue* default_value_;
565 ::tensorflow::AttrValue* allowed_values_;
566 ::int64_t minimum_;
567 bool has_minimum_;
568 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
569 };
570 union { Impl_ _impl_; };
571 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
572 };
573 // -------------------------------------------------------------------
574
575 class OpDef final :
576 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpDef) */ {
577 public:
OpDef()578 inline OpDef() : OpDef(nullptr) {}
579 ~OpDef() override;
580 explicit PROTOBUF_CONSTEXPR OpDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
581
582 OpDef(const OpDef& from);
OpDef(OpDef && from)583 OpDef(OpDef&& from) noexcept
584 : OpDef() {
585 *this = ::std::move(from);
586 }
587
588 inline OpDef& operator=(const OpDef& from) {
589 if (this == &from) return *this;
590 CopyFrom(from);
591 return *this;
592 }
593 inline OpDef& operator=(OpDef&& from) noexcept {
594 if (this == &from) return *this;
595 if (GetOwningArena() == from.GetOwningArena()
596 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
597 && GetOwningArena() != nullptr
598 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
599 ) {
600 InternalSwap(&from);
601 } else {
602 CopyFrom(from);
603 }
604 return *this;
605 }
606
default_instance()607 static const OpDef& default_instance() {
608 return *internal_default_instance();
609 }
internal_default_instance()610 static inline const OpDef* internal_default_instance() {
611 return reinterpret_cast<const OpDef*>(
612 &_OpDef_default_instance_);
613 }
614 static constexpr int kIndexInFileMessages =
615 2;
616
swap(OpDef & a,OpDef & b)617 friend void swap(OpDef& a, OpDef& b) {
618 a.Swap(&b);
619 }
Swap(OpDef * other)620 inline void Swap(OpDef* other) {
621 if (other == this) return;
622 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
623 if (GetOwningArena() != nullptr &&
624 GetOwningArena() == other->GetOwningArena()) {
625 #else // PROTOBUF_FORCE_COPY_IN_SWAP
626 if (GetOwningArena() == other->GetOwningArena()) {
627 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
628 InternalSwap(other);
629 } else {
630 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
631 }
632 }
633 void UnsafeArenaSwap(OpDef* other) {
634 if (other == this) return;
635 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
636 InternalSwap(other);
637 }
638
639 // implements Message ----------------------------------------------
640
641 OpDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
642 return CreateMaybeMessage<OpDef>(arena);
643 }
644 OpDef* New() const {
645 return New(nullptr);
646 }
647 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
648 void CopyFrom(const OpDef& from);
649 void MergeFrom(const OpDef& from);
650 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
651 bool IsInitialized() const final;
652
653 size_t ByteSizeLong() const final;
654 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
655 ::uint8_t* _InternalSerialize(
656 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
657 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
658
659 private:
660 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
661 void SharedDtor();
662 void SetCachedSize(int size) const;
663 void InternalSwap(OpDef* other);
664
665 private:
666 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
667 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
668 return "tensorflow.OpDef";
669 }
670 protected:
671 explicit OpDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
672 bool is_message_owned = false);
673 public:
674
675 std::string GetTypeName() const final;
676
677 // nested types ----------------------------------------------------
678
679 typedef OpDef_ArgDef ArgDef;
680 typedef OpDef_AttrDef AttrDef;
681
682 // accessors -------------------------------------------------------
683
684 enum : int {
685 kInputArgFieldNumber = 2,
686 kOutputArgFieldNumber = 3,
687 kAttrFieldNumber = 4,
688 kControlOutputFieldNumber = 20,
689 kNameFieldNumber = 1,
690 kSummaryFieldNumber = 5,
691 kDescriptionFieldNumber = 6,
692 kDeprecationFieldNumber = 8,
693 kIsCommutativeFieldNumber = 18,
694 kIsAggregateFieldNumber = 16,
695 kIsStatefulFieldNumber = 17,
696 kAllowsUninitializedInputFieldNumber = 19,
697 kIsDistributedCommunicationFieldNumber = 21,
698 };
699 // repeated .tensorflow.OpDef.ArgDef input_arg = 2;
700 int input_arg_size() const;
701 private:
702 int _internal_input_arg_size() const;
703 public:
704 void clear_input_arg();
705 ::tensorflow::OpDef_ArgDef* mutable_input_arg(int index);
706 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
707 mutable_input_arg();
708 private:
709 const ::tensorflow::OpDef_ArgDef& _internal_input_arg(int index) const;
710 ::tensorflow::OpDef_ArgDef* _internal_add_input_arg();
711 public:
712 const ::tensorflow::OpDef_ArgDef& input_arg(int index) const;
713 ::tensorflow::OpDef_ArgDef* add_input_arg();
714 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
715 input_arg() const;
716
717 // repeated .tensorflow.OpDef.ArgDef output_arg = 3;
718 int output_arg_size() const;
719 private:
720 int _internal_output_arg_size() const;
721 public:
722 void clear_output_arg();
723 ::tensorflow::OpDef_ArgDef* mutable_output_arg(int index);
724 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
725 mutable_output_arg();
726 private:
727 const ::tensorflow::OpDef_ArgDef& _internal_output_arg(int index) const;
728 ::tensorflow::OpDef_ArgDef* _internal_add_output_arg();
729 public:
730 const ::tensorflow::OpDef_ArgDef& output_arg(int index) const;
731 ::tensorflow::OpDef_ArgDef* add_output_arg();
732 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
733 output_arg() const;
734
735 // repeated .tensorflow.OpDef.AttrDef attr = 4;
736 int attr_size() const;
737 private:
738 int _internal_attr_size() const;
739 public:
740 void clear_attr();
741 ::tensorflow::OpDef_AttrDef* mutable_attr(int index);
742 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >*
743 mutable_attr();
744 private:
745 const ::tensorflow::OpDef_AttrDef& _internal_attr(int index) const;
746 ::tensorflow::OpDef_AttrDef* _internal_add_attr();
747 public:
748 const ::tensorflow::OpDef_AttrDef& attr(int index) const;
749 ::tensorflow::OpDef_AttrDef* add_attr();
750 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >&
751 attr() const;
752
753 // repeated string control_output = 20;
754 int control_output_size() const;
755 private:
756 int _internal_control_output_size() const;
757 public:
758 void clear_control_output();
759 const std::string& control_output(int index) const;
760 std::string* mutable_control_output(int index);
761 void set_control_output(int index, const std::string& value);
762 void set_control_output(int index, std::string&& value);
763 void set_control_output(int index, const char* value);
764 void set_control_output(int index, const char* value, size_t size);
765 std::string* add_control_output();
766 void add_control_output(const std::string& value);
767 void add_control_output(std::string&& value);
768 void add_control_output(const char* value);
769 void add_control_output(const char* value, size_t size);
770 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& control_output() const;
771 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_control_output();
772 private:
773 const std::string& _internal_control_output(int index) const;
774 std::string* _internal_add_control_output();
775 public:
776
777 // string name = 1;
778 void clear_name();
779 const std::string& name() const;
780 template <typename ArgT0 = const std::string&, typename... ArgT>
781 void set_name(ArgT0&& arg0, ArgT... args);
782 std::string* mutable_name();
783 PROTOBUF_NODISCARD std::string* release_name();
784 void set_allocated_name(std::string* name);
785 private:
786 const std::string& _internal_name() const;
787 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
788 std::string* _internal_mutable_name();
789 public:
790
791 // string summary = 5;
792 void clear_summary();
793 const std::string& summary() const;
794 template <typename ArgT0 = const std::string&, typename... ArgT>
795 void set_summary(ArgT0&& arg0, ArgT... args);
796 std::string* mutable_summary();
797 PROTOBUF_NODISCARD std::string* release_summary();
798 void set_allocated_summary(std::string* summary);
799 private:
800 const std::string& _internal_summary() const;
801 inline PROTOBUF_ALWAYS_INLINE void _internal_set_summary(const std::string& value);
802 std::string* _internal_mutable_summary();
803 public:
804
805 // string description = 6;
806 void clear_description();
807 const std::string& description() const;
808 template <typename ArgT0 = const std::string&, typename... ArgT>
809 void set_description(ArgT0&& arg0, ArgT... args);
810 std::string* mutable_description();
811 PROTOBUF_NODISCARD std::string* release_description();
812 void set_allocated_description(std::string* description);
813 private:
814 const std::string& _internal_description() const;
815 inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
816 std::string* _internal_mutable_description();
817 public:
818
819 // .tensorflow.OpDeprecation deprecation = 8;
820 bool has_deprecation() const;
821 private:
822 bool _internal_has_deprecation() const;
823 public:
824 void clear_deprecation();
825 const ::tensorflow::OpDeprecation& deprecation() const;
826 PROTOBUF_NODISCARD ::tensorflow::OpDeprecation* release_deprecation();
827 ::tensorflow::OpDeprecation* mutable_deprecation();
828 void set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation);
829 private:
830 const ::tensorflow::OpDeprecation& _internal_deprecation() const;
831 ::tensorflow::OpDeprecation* _internal_mutable_deprecation();
832 public:
833 void unsafe_arena_set_allocated_deprecation(
834 ::tensorflow::OpDeprecation* deprecation);
835 ::tensorflow::OpDeprecation* unsafe_arena_release_deprecation();
836
837 // bool is_commutative = 18;
838 void clear_is_commutative();
839 bool is_commutative() const;
840 void set_is_commutative(bool value);
841 private:
842 bool _internal_is_commutative() const;
843 void _internal_set_is_commutative(bool value);
844 public:
845
846 // bool is_aggregate = 16;
847 void clear_is_aggregate();
848 bool is_aggregate() const;
849 void set_is_aggregate(bool value);
850 private:
851 bool _internal_is_aggregate() const;
852 void _internal_set_is_aggregate(bool value);
853 public:
854
855 // bool is_stateful = 17;
856 void clear_is_stateful();
857 bool is_stateful() const;
858 void set_is_stateful(bool value);
859 private:
860 bool _internal_is_stateful() const;
861 void _internal_set_is_stateful(bool value);
862 public:
863
864 // bool allows_uninitialized_input = 19;
865 void clear_allows_uninitialized_input();
866 bool allows_uninitialized_input() const;
867 void set_allows_uninitialized_input(bool value);
868 private:
869 bool _internal_allows_uninitialized_input() const;
870 void _internal_set_allows_uninitialized_input(bool value);
871 public:
872
873 // bool is_distributed_communication = 21;
874 void clear_is_distributed_communication();
875 bool is_distributed_communication() const;
876 void set_is_distributed_communication(bool value);
877 private:
878 bool _internal_is_distributed_communication() const;
879 void _internal_set_is_distributed_communication(bool value);
880 public:
881
882 // @@protoc_insertion_point(class_scope:tensorflow.OpDef)
883 private:
884 class _Internal;
885
886 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
887 typedef void InternalArenaConstructable_;
888 typedef void DestructorSkippable_;
889 struct Impl_ {
890 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > input_arg_;
891 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef > output_arg_;
892 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef > attr_;
893 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> control_output_;
894 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
895 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr summary_;
896 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
897 ::tensorflow::OpDeprecation* deprecation_;
898 bool is_commutative_;
899 bool is_aggregate_;
900 bool is_stateful_;
901 bool allows_uninitialized_input_;
902 bool is_distributed_communication_;
903 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
904 };
905 union { Impl_ _impl_; };
906 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
907 };
908 // -------------------------------------------------------------------
909
910 class OpDeprecation final :
911 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpDeprecation) */ {
912 public:
OpDeprecation()913 inline OpDeprecation() : OpDeprecation(nullptr) {}
914 ~OpDeprecation() override;
915 explicit PROTOBUF_CONSTEXPR OpDeprecation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
916
917 OpDeprecation(const OpDeprecation& from);
OpDeprecation(OpDeprecation && from)918 OpDeprecation(OpDeprecation&& from) noexcept
919 : OpDeprecation() {
920 *this = ::std::move(from);
921 }
922
923 inline OpDeprecation& operator=(const OpDeprecation& from) {
924 if (this == &from) return *this;
925 CopyFrom(from);
926 return *this;
927 }
928 inline OpDeprecation& operator=(OpDeprecation&& from) noexcept {
929 if (this == &from) return *this;
930 if (GetOwningArena() == from.GetOwningArena()
931 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
932 && GetOwningArena() != nullptr
933 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
934 ) {
935 InternalSwap(&from);
936 } else {
937 CopyFrom(from);
938 }
939 return *this;
940 }
941
default_instance()942 static const OpDeprecation& default_instance() {
943 return *internal_default_instance();
944 }
internal_default_instance()945 static inline const OpDeprecation* internal_default_instance() {
946 return reinterpret_cast<const OpDeprecation*>(
947 &_OpDeprecation_default_instance_);
948 }
949 static constexpr int kIndexInFileMessages =
950 3;
951
swap(OpDeprecation & a,OpDeprecation & b)952 friend void swap(OpDeprecation& a, OpDeprecation& b) {
953 a.Swap(&b);
954 }
Swap(OpDeprecation * other)955 inline void Swap(OpDeprecation* other) {
956 if (other == this) return;
957 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
958 if (GetOwningArena() != nullptr &&
959 GetOwningArena() == other->GetOwningArena()) {
960 #else // PROTOBUF_FORCE_COPY_IN_SWAP
961 if (GetOwningArena() == other->GetOwningArena()) {
962 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
963 InternalSwap(other);
964 } else {
965 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
966 }
967 }
968 void UnsafeArenaSwap(OpDeprecation* other) {
969 if (other == this) return;
970 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
971 InternalSwap(other);
972 }
973
974 // implements Message ----------------------------------------------
975
976 OpDeprecation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
977 return CreateMaybeMessage<OpDeprecation>(arena);
978 }
979 OpDeprecation* New() const {
980 return New(nullptr);
981 }
982 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
983 void CopyFrom(const OpDeprecation& from);
984 void MergeFrom(const OpDeprecation& from);
985 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
986 bool IsInitialized() const final;
987
988 size_t ByteSizeLong() const final;
989 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
990 ::uint8_t* _InternalSerialize(
991 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
992 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
993
994 private:
995 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
996 void SharedDtor();
997 void SetCachedSize(int size) const;
998 void InternalSwap(OpDeprecation* other);
999
1000 private:
1001 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1002 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1003 return "tensorflow.OpDeprecation";
1004 }
1005 protected:
1006 explicit OpDeprecation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1007 bool is_message_owned = false);
1008 public:
1009
1010 std::string GetTypeName() const final;
1011
1012 // nested types ----------------------------------------------------
1013
1014 // accessors -------------------------------------------------------
1015
1016 enum : int {
1017 kExplanationFieldNumber = 2,
1018 kVersionFieldNumber = 1,
1019 };
1020 // string explanation = 2;
1021 void clear_explanation();
1022 const std::string& explanation() const;
1023 template <typename ArgT0 = const std::string&, typename... ArgT>
1024 void set_explanation(ArgT0&& arg0, ArgT... args);
1025 std::string* mutable_explanation();
1026 PROTOBUF_NODISCARD std::string* release_explanation();
1027 void set_allocated_explanation(std::string* explanation);
1028 private:
1029 const std::string& _internal_explanation() const;
1030 inline PROTOBUF_ALWAYS_INLINE void _internal_set_explanation(const std::string& value);
1031 std::string* _internal_mutable_explanation();
1032 public:
1033
1034 // int32 version = 1;
1035 void clear_version();
1036 ::int32_t version() const;
1037 void set_version(::int32_t value);
1038 private:
1039 ::int32_t _internal_version() const;
1040 void _internal_set_version(::int32_t value);
1041 public:
1042
1043 // @@protoc_insertion_point(class_scope:tensorflow.OpDeprecation)
1044 private:
1045 class _Internal;
1046
1047 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1048 typedef void InternalArenaConstructable_;
1049 typedef void DestructorSkippable_;
1050 struct Impl_ {
1051 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr explanation_;
1052 ::int32_t version_;
1053 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1054 };
1055 union { Impl_ _impl_; };
1056 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
1057 };
1058 // -------------------------------------------------------------------
1059
1060 class OpList final :
1061 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.OpList) */ {
1062 public:
OpList()1063 inline OpList() : OpList(nullptr) {}
1064 ~OpList() override;
1065 explicit PROTOBUF_CONSTEXPR OpList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1066
1067 OpList(const OpList& from);
OpList(OpList && from)1068 OpList(OpList&& from) noexcept
1069 : OpList() {
1070 *this = ::std::move(from);
1071 }
1072
1073 inline OpList& operator=(const OpList& from) {
1074 if (this == &from) return *this;
1075 CopyFrom(from);
1076 return *this;
1077 }
1078 inline OpList& operator=(OpList&& from) noexcept {
1079 if (this == &from) return *this;
1080 if (GetOwningArena() == from.GetOwningArena()
1081 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1082 && GetOwningArena() != nullptr
1083 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1084 ) {
1085 InternalSwap(&from);
1086 } else {
1087 CopyFrom(from);
1088 }
1089 return *this;
1090 }
1091
default_instance()1092 static const OpList& default_instance() {
1093 return *internal_default_instance();
1094 }
internal_default_instance()1095 static inline const OpList* internal_default_instance() {
1096 return reinterpret_cast<const OpList*>(
1097 &_OpList_default_instance_);
1098 }
1099 static constexpr int kIndexInFileMessages =
1100 4;
1101
swap(OpList & a,OpList & b)1102 friend void swap(OpList& a, OpList& b) {
1103 a.Swap(&b);
1104 }
Swap(OpList * other)1105 inline void Swap(OpList* other) {
1106 if (other == this) return;
1107 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1108 if (GetOwningArena() != nullptr &&
1109 GetOwningArena() == other->GetOwningArena()) {
1110 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1111 if (GetOwningArena() == other->GetOwningArena()) {
1112 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1113 InternalSwap(other);
1114 } else {
1115 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1116 }
1117 }
1118 void UnsafeArenaSwap(OpList* other) {
1119 if (other == this) return;
1120 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1121 InternalSwap(other);
1122 }
1123
1124 // implements Message ----------------------------------------------
1125
1126 OpList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1127 return CreateMaybeMessage<OpList>(arena);
1128 }
1129 OpList* New() const {
1130 return New(nullptr);
1131 }
1132 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1133 void CopyFrom(const OpList& from);
1134 void MergeFrom(const OpList& from);
1135 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1136 bool IsInitialized() const final;
1137
1138 size_t ByteSizeLong() const final;
1139 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1140 ::uint8_t* _InternalSerialize(
1141 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1142 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1143
1144 private:
1145 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1146 void SharedDtor();
1147 void SetCachedSize(int size) const;
1148 void InternalSwap(OpList* other);
1149
1150 private:
1151 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1152 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1153 return "tensorflow.OpList";
1154 }
1155 protected:
1156 explicit OpList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1157 bool is_message_owned = false);
1158 public:
1159
1160 std::string GetTypeName() const final;
1161
1162 // nested types ----------------------------------------------------
1163
1164 // accessors -------------------------------------------------------
1165
1166 enum : int {
1167 kOpFieldNumber = 1,
1168 };
1169 // repeated .tensorflow.OpDef op = 1;
1170 int op_size() const;
1171 private:
1172 int _internal_op_size() const;
1173 public:
1174 void clear_op();
1175 ::tensorflow::OpDef* mutable_op(int index);
1176 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >*
1177 mutable_op();
1178 private:
1179 const ::tensorflow::OpDef& _internal_op(int index) const;
1180 ::tensorflow::OpDef* _internal_add_op();
1181 public:
1182 const ::tensorflow::OpDef& op(int index) const;
1183 ::tensorflow::OpDef* add_op();
1184 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >&
1185 op() const;
1186
1187 // @@protoc_insertion_point(class_scope:tensorflow.OpList)
1188 private:
1189 class _Internal;
1190
1191 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1192 typedef void InternalArenaConstructable_;
1193 typedef void DestructorSkippable_;
1194 struct Impl_ {
1195 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef > op_;
1196 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1197 };
1198 union { Impl_ _impl_; };
1199 friend struct ::TableStruct_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto;
1200 };
1201 // ===================================================================
1202
1203
1204 // ===================================================================
1205
1206 #ifdef __GNUC__
1207 #pragma GCC diagnostic push
1208 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1209 #endif // __GNUC__
1210 // OpDef_ArgDef
1211
1212 // string name = 1;
clear_name()1213 inline void OpDef_ArgDef::clear_name() {
1214 _impl_.name_.ClearToEmpty();
1215 }
name()1216 inline const std::string& OpDef_ArgDef::name() const {
1217 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.name)
1218 return _internal_name();
1219 }
1220 template <typename ArgT0, typename... ArgT>
1221 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1222 void OpDef_ArgDef::set_name(ArgT0&& arg0, ArgT... args) {
1223
1224 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1225 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.name)
1226 }
mutable_name()1227 inline std::string* OpDef_ArgDef::mutable_name() {
1228 std::string* _s = _internal_mutable_name();
1229 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.name)
1230 return _s;
1231 }
_internal_name()1232 inline const std::string& OpDef_ArgDef::_internal_name() const {
1233 return _impl_.name_.Get();
1234 }
_internal_set_name(const std::string & value)1235 inline void OpDef_ArgDef::_internal_set_name(const std::string& value) {
1236
1237 _impl_.name_.Set(value, GetArenaForAllocation());
1238 }
_internal_mutable_name()1239 inline std::string* OpDef_ArgDef::_internal_mutable_name() {
1240
1241 return _impl_.name_.Mutable(GetArenaForAllocation());
1242 }
release_name()1243 inline std::string* OpDef_ArgDef::release_name() {
1244 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.name)
1245 return _impl_.name_.Release();
1246 }
set_allocated_name(std::string * name)1247 inline void OpDef_ArgDef::set_allocated_name(std::string* name) {
1248 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1249 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1250 if (_impl_.name_.IsDefault()) {
1251 _impl_.name_.Set("", GetArenaForAllocation());
1252 }
1253 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1254 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.name)
1255 }
1256
1257 // string description = 2;
clear_description()1258 inline void OpDef_ArgDef::clear_description() {
1259 _impl_.description_.ClearToEmpty();
1260 }
description()1261 inline const std::string& OpDef_ArgDef::description() const {
1262 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.description)
1263 return _internal_description();
1264 }
1265 template <typename ArgT0, typename... ArgT>
1266 inline PROTOBUF_ALWAYS_INLINE
set_description(ArgT0 && arg0,ArgT...args)1267 void OpDef_ArgDef::set_description(ArgT0&& arg0, ArgT... args) {
1268
1269 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1270 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.description)
1271 }
mutable_description()1272 inline std::string* OpDef_ArgDef::mutable_description() {
1273 std::string* _s = _internal_mutable_description();
1274 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.description)
1275 return _s;
1276 }
_internal_description()1277 inline const std::string& OpDef_ArgDef::_internal_description() const {
1278 return _impl_.description_.Get();
1279 }
_internal_set_description(const std::string & value)1280 inline void OpDef_ArgDef::_internal_set_description(const std::string& value) {
1281
1282 _impl_.description_.Set(value, GetArenaForAllocation());
1283 }
_internal_mutable_description()1284 inline std::string* OpDef_ArgDef::_internal_mutable_description() {
1285
1286 return _impl_.description_.Mutable(GetArenaForAllocation());
1287 }
release_description()1288 inline std::string* OpDef_ArgDef::release_description() {
1289 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.description)
1290 return _impl_.description_.Release();
1291 }
set_allocated_description(std::string * description)1292 inline void OpDef_ArgDef::set_allocated_description(std::string* description) {
1293 _impl_.description_.SetAllocated(description, GetArenaForAllocation());
1294 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1295 if (_impl_.description_.IsDefault()) {
1296 _impl_.description_.Set("", GetArenaForAllocation());
1297 }
1298 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1299 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.description)
1300 }
1301
1302 // .tensorflow.DataType type = 3;
clear_type()1303 inline void OpDef_ArgDef::clear_type() {
1304 _impl_.type_ = 0;
1305 }
_internal_type()1306 inline ::tensorflow::DataType OpDef_ArgDef::_internal_type() const {
1307 return static_cast< ::tensorflow::DataType >(_impl_.type_);
1308 }
type()1309 inline ::tensorflow::DataType OpDef_ArgDef::type() const {
1310 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type)
1311 return _internal_type();
1312 }
_internal_set_type(::tensorflow::DataType value)1313 inline void OpDef_ArgDef::_internal_set_type(::tensorflow::DataType value) {
1314
1315 _impl_.type_ = value;
1316 }
set_type(::tensorflow::DataType value)1317 inline void OpDef_ArgDef::set_type(::tensorflow::DataType value) {
1318 _internal_set_type(value);
1319 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type)
1320 }
1321
1322 // string type_attr = 4;
clear_type_attr()1323 inline void OpDef_ArgDef::clear_type_attr() {
1324 _impl_.type_attr_.ClearToEmpty();
1325 }
type_attr()1326 inline const std::string& OpDef_ArgDef::type_attr() const {
1327 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_attr)
1328 return _internal_type_attr();
1329 }
1330 template <typename ArgT0, typename... ArgT>
1331 inline PROTOBUF_ALWAYS_INLINE
set_type_attr(ArgT0 && arg0,ArgT...args)1332 void OpDef_ArgDef::set_type_attr(ArgT0&& arg0, ArgT... args) {
1333
1334 _impl_.type_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1335 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_attr)
1336 }
mutable_type_attr()1337 inline std::string* OpDef_ArgDef::mutable_type_attr() {
1338 std::string* _s = _internal_mutable_type_attr();
1339 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_attr)
1340 return _s;
1341 }
_internal_type_attr()1342 inline const std::string& OpDef_ArgDef::_internal_type_attr() const {
1343 return _impl_.type_attr_.Get();
1344 }
_internal_set_type_attr(const std::string & value)1345 inline void OpDef_ArgDef::_internal_set_type_attr(const std::string& value) {
1346
1347 _impl_.type_attr_.Set(value, GetArenaForAllocation());
1348 }
_internal_mutable_type_attr()1349 inline std::string* OpDef_ArgDef::_internal_mutable_type_attr() {
1350
1351 return _impl_.type_attr_.Mutable(GetArenaForAllocation());
1352 }
release_type_attr()1353 inline std::string* OpDef_ArgDef::release_type_attr() {
1354 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_attr)
1355 return _impl_.type_attr_.Release();
1356 }
set_allocated_type_attr(std::string * type_attr)1357 inline void OpDef_ArgDef::set_allocated_type_attr(std::string* type_attr) {
1358 _impl_.type_attr_.SetAllocated(type_attr, GetArenaForAllocation());
1359 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1360 if (_impl_.type_attr_.IsDefault()) {
1361 _impl_.type_attr_.Set("", GetArenaForAllocation());
1362 }
1363 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1364 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_attr)
1365 }
1366
1367 // string number_attr = 5;
clear_number_attr()1368 inline void OpDef_ArgDef::clear_number_attr() {
1369 _impl_.number_attr_.ClearToEmpty();
1370 }
number_attr()1371 inline const std::string& OpDef_ArgDef::number_attr() const {
1372 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.number_attr)
1373 return _internal_number_attr();
1374 }
1375 template <typename ArgT0, typename... ArgT>
1376 inline PROTOBUF_ALWAYS_INLINE
set_number_attr(ArgT0 && arg0,ArgT...args)1377 void OpDef_ArgDef::set_number_attr(ArgT0&& arg0, ArgT... args) {
1378
1379 _impl_.number_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1380 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.number_attr)
1381 }
mutable_number_attr()1382 inline std::string* OpDef_ArgDef::mutable_number_attr() {
1383 std::string* _s = _internal_mutable_number_attr();
1384 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.number_attr)
1385 return _s;
1386 }
_internal_number_attr()1387 inline const std::string& OpDef_ArgDef::_internal_number_attr() const {
1388 return _impl_.number_attr_.Get();
1389 }
_internal_set_number_attr(const std::string & value)1390 inline void OpDef_ArgDef::_internal_set_number_attr(const std::string& value) {
1391
1392 _impl_.number_attr_.Set(value, GetArenaForAllocation());
1393 }
_internal_mutable_number_attr()1394 inline std::string* OpDef_ArgDef::_internal_mutable_number_attr() {
1395
1396 return _impl_.number_attr_.Mutable(GetArenaForAllocation());
1397 }
release_number_attr()1398 inline std::string* OpDef_ArgDef::release_number_attr() {
1399 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.number_attr)
1400 return _impl_.number_attr_.Release();
1401 }
set_allocated_number_attr(std::string * number_attr)1402 inline void OpDef_ArgDef::set_allocated_number_attr(std::string* number_attr) {
1403 _impl_.number_attr_.SetAllocated(number_attr, GetArenaForAllocation());
1404 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1405 if (_impl_.number_attr_.IsDefault()) {
1406 _impl_.number_attr_.Set("", GetArenaForAllocation());
1407 }
1408 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1409 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.number_attr)
1410 }
1411
1412 // string type_list_attr = 6;
clear_type_list_attr()1413 inline void OpDef_ArgDef::clear_type_list_attr() {
1414 _impl_.type_list_attr_.ClearToEmpty();
1415 }
type_list_attr()1416 inline const std::string& OpDef_ArgDef::type_list_attr() const {
1417 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.type_list_attr)
1418 return _internal_type_list_attr();
1419 }
1420 template <typename ArgT0, typename... ArgT>
1421 inline PROTOBUF_ALWAYS_INLINE
set_type_list_attr(ArgT0 && arg0,ArgT...args)1422 void OpDef_ArgDef::set_type_list_attr(ArgT0&& arg0, ArgT... args) {
1423
1424 _impl_.type_list_attr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1425 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.type_list_attr)
1426 }
mutable_type_list_attr()1427 inline std::string* OpDef_ArgDef::mutable_type_list_attr() {
1428 std::string* _s = _internal_mutable_type_list_attr();
1429 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.type_list_attr)
1430 return _s;
1431 }
_internal_type_list_attr()1432 inline const std::string& OpDef_ArgDef::_internal_type_list_attr() const {
1433 return _impl_.type_list_attr_.Get();
1434 }
_internal_set_type_list_attr(const std::string & value)1435 inline void OpDef_ArgDef::_internal_set_type_list_attr(const std::string& value) {
1436
1437 _impl_.type_list_attr_.Set(value, GetArenaForAllocation());
1438 }
_internal_mutable_type_list_attr()1439 inline std::string* OpDef_ArgDef::_internal_mutable_type_list_attr() {
1440
1441 return _impl_.type_list_attr_.Mutable(GetArenaForAllocation());
1442 }
release_type_list_attr()1443 inline std::string* OpDef_ArgDef::release_type_list_attr() {
1444 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.type_list_attr)
1445 return _impl_.type_list_attr_.Release();
1446 }
set_allocated_type_list_attr(std::string * type_list_attr)1447 inline void OpDef_ArgDef::set_allocated_type_list_attr(std::string* type_list_attr) {
1448 _impl_.type_list_attr_.SetAllocated(type_list_attr, GetArenaForAllocation());
1449 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1450 if (_impl_.type_list_attr_.IsDefault()) {
1451 _impl_.type_list_attr_.Set("", GetArenaForAllocation());
1452 }
1453 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1454 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.type_list_attr)
1455 }
1456
1457 // repeated .tensorflow.ResourceHandleProto.DtypeAndShape handle_data = 7;
_internal_handle_data_size()1458 inline int OpDef_ArgDef::_internal_handle_data_size() const {
1459 return _impl_.handle_data_.size();
1460 }
handle_data_size()1461 inline int OpDef_ArgDef::handle_data_size() const {
1462 return _internal_handle_data_size();
1463 }
mutable_handle_data(int index)1464 inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::mutable_handle_data(int index) {
1465 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.handle_data)
1466 return _impl_.handle_data_.Mutable(index);
1467 }
1468 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >*
mutable_handle_data()1469 OpDef_ArgDef::mutable_handle_data() {
1470 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.ArgDef.handle_data)
1471 return &_impl_.handle_data_;
1472 }
_internal_handle_data(int index)1473 inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& OpDef_ArgDef::_internal_handle_data(int index) const {
1474 return _impl_.handle_data_.Get(index);
1475 }
handle_data(int index)1476 inline const ::tensorflow::ResourceHandleProto_DtypeAndShape& OpDef_ArgDef::handle_data(int index) const {
1477 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.handle_data)
1478 return _internal_handle_data(index);
1479 }
_internal_add_handle_data()1480 inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::_internal_add_handle_data() {
1481 return _impl_.handle_data_.Add();
1482 }
add_handle_data()1483 inline ::tensorflow::ResourceHandleProto_DtypeAndShape* OpDef_ArgDef::add_handle_data() {
1484 ::tensorflow::ResourceHandleProto_DtypeAndShape* _add = _internal_add_handle_data();
1485 // @@protoc_insertion_point(field_add:tensorflow.OpDef.ArgDef.handle_data)
1486 return _add;
1487 }
1488 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::ResourceHandleProto_DtypeAndShape >&
handle_data()1489 OpDef_ArgDef::handle_data() const {
1490 // @@protoc_insertion_point(field_list:tensorflow.OpDef.ArgDef.handle_data)
1491 return _impl_.handle_data_;
1492 }
1493
1494 // bool is_ref = 16;
clear_is_ref()1495 inline void OpDef_ArgDef::clear_is_ref() {
1496 _impl_.is_ref_ = false;
1497 }
_internal_is_ref()1498 inline bool OpDef_ArgDef::_internal_is_ref() const {
1499 return _impl_.is_ref_;
1500 }
is_ref()1501 inline bool OpDef_ArgDef::is_ref() const {
1502 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.is_ref)
1503 return _internal_is_ref();
1504 }
_internal_set_is_ref(bool value)1505 inline void OpDef_ArgDef::_internal_set_is_ref(bool value) {
1506
1507 _impl_.is_ref_ = value;
1508 }
set_is_ref(bool value)1509 inline void OpDef_ArgDef::set_is_ref(bool value) {
1510 _internal_set_is_ref(value);
1511 // @@protoc_insertion_point(field_set:tensorflow.OpDef.ArgDef.is_ref)
1512 }
1513
1514 // .tensorflow.FullTypeDef experimental_full_type = 17;
_internal_has_experimental_full_type()1515 inline bool OpDef_ArgDef::_internal_has_experimental_full_type() const {
1516 return this != internal_default_instance() && _impl_.experimental_full_type_ != nullptr;
1517 }
has_experimental_full_type()1518 inline bool OpDef_ArgDef::has_experimental_full_type() const {
1519 return _internal_has_experimental_full_type();
1520 }
_internal_experimental_full_type()1521 inline const ::tensorflow::FullTypeDef& OpDef_ArgDef::_internal_experimental_full_type() const {
1522 const ::tensorflow::FullTypeDef* p = _impl_.experimental_full_type_;
1523 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FullTypeDef&>(
1524 ::tensorflow::_FullTypeDef_default_instance_);
1525 }
experimental_full_type()1526 inline const ::tensorflow::FullTypeDef& OpDef_ArgDef::experimental_full_type() const {
1527 // @@protoc_insertion_point(field_get:tensorflow.OpDef.ArgDef.experimental_full_type)
1528 return _internal_experimental_full_type();
1529 }
unsafe_arena_set_allocated_experimental_full_type(::tensorflow::FullTypeDef * experimental_full_type)1530 inline void OpDef_ArgDef::unsafe_arena_set_allocated_experimental_full_type(
1531 ::tensorflow::FullTypeDef* experimental_full_type) {
1532 if (GetArenaForAllocation() == nullptr) {
1533 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_full_type_);
1534 }
1535 _impl_.experimental_full_type_ = experimental_full_type;
1536 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.ArgDef.experimental_full_type)
1537 }
release_experimental_full_type()1538 inline ::tensorflow::FullTypeDef* OpDef_ArgDef::release_experimental_full_type() {
1539
1540 ::tensorflow::FullTypeDef* temp = _impl_.experimental_full_type_;
1541 _impl_.experimental_full_type_ = nullptr;
1542 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1543 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1544 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1545 if (GetArenaForAllocation() == nullptr) { delete old; }
1546 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1547 if (GetArenaForAllocation() != nullptr) {
1548 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1549 }
1550 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1551 return temp;
1552 }
unsafe_arena_release_experimental_full_type()1553 inline ::tensorflow::FullTypeDef* OpDef_ArgDef::unsafe_arena_release_experimental_full_type() {
1554 // @@protoc_insertion_point(field_release:tensorflow.OpDef.ArgDef.experimental_full_type)
1555
1556 ::tensorflow::FullTypeDef* temp = _impl_.experimental_full_type_;
1557 _impl_.experimental_full_type_ = nullptr;
1558 return temp;
1559 }
_internal_mutable_experimental_full_type()1560 inline ::tensorflow::FullTypeDef* OpDef_ArgDef::_internal_mutable_experimental_full_type() {
1561
1562 if (_impl_.experimental_full_type_ == nullptr) {
1563 auto* p = CreateMaybeMessage<::tensorflow::FullTypeDef>(GetArenaForAllocation());
1564 _impl_.experimental_full_type_ = p;
1565 }
1566 return _impl_.experimental_full_type_;
1567 }
mutable_experimental_full_type()1568 inline ::tensorflow::FullTypeDef* OpDef_ArgDef::mutable_experimental_full_type() {
1569 ::tensorflow::FullTypeDef* _msg = _internal_mutable_experimental_full_type();
1570 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.ArgDef.experimental_full_type)
1571 return _msg;
1572 }
set_allocated_experimental_full_type(::tensorflow::FullTypeDef * experimental_full_type)1573 inline void OpDef_ArgDef::set_allocated_experimental_full_type(::tensorflow::FullTypeDef* experimental_full_type) {
1574 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1575 if (message_arena == nullptr) {
1576 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.experimental_full_type_);
1577 }
1578 if (experimental_full_type) {
1579 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1580 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1581 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(experimental_full_type));
1582 if (message_arena != submessage_arena) {
1583 experimental_full_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1584 message_arena, experimental_full_type, submessage_arena);
1585 }
1586
1587 } else {
1588
1589 }
1590 _impl_.experimental_full_type_ = experimental_full_type;
1591 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.ArgDef.experimental_full_type)
1592 }
1593
1594 // -------------------------------------------------------------------
1595
1596 // OpDef_AttrDef
1597
1598 // string name = 1;
clear_name()1599 inline void OpDef_AttrDef::clear_name() {
1600 _impl_.name_.ClearToEmpty();
1601 }
name()1602 inline const std::string& OpDef_AttrDef::name() const {
1603 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.name)
1604 return _internal_name();
1605 }
1606 template <typename ArgT0, typename... ArgT>
1607 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1608 void OpDef_AttrDef::set_name(ArgT0&& arg0, ArgT... args) {
1609
1610 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1611 // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.name)
1612 }
mutable_name()1613 inline std::string* OpDef_AttrDef::mutable_name() {
1614 std::string* _s = _internal_mutable_name();
1615 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.name)
1616 return _s;
1617 }
_internal_name()1618 inline const std::string& OpDef_AttrDef::_internal_name() const {
1619 return _impl_.name_.Get();
1620 }
_internal_set_name(const std::string & value)1621 inline void OpDef_AttrDef::_internal_set_name(const std::string& value) {
1622
1623 _impl_.name_.Set(value, GetArenaForAllocation());
1624 }
_internal_mutable_name()1625 inline std::string* OpDef_AttrDef::_internal_mutable_name() {
1626
1627 return _impl_.name_.Mutable(GetArenaForAllocation());
1628 }
release_name()1629 inline std::string* OpDef_AttrDef::release_name() {
1630 // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.name)
1631 return _impl_.name_.Release();
1632 }
set_allocated_name(std::string * name)1633 inline void OpDef_AttrDef::set_allocated_name(std::string* name) {
1634 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1635 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1636 if (_impl_.name_.IsDefault()) {
1637 _impl_.name_.Set("", GetArenaForAllocation());
1638 }
1639 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1640 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.name)
1641 }
1642
1643 // string type = 2;
clear_type()1644 inline void OpDef_AttrDef::clear_type() {
1645 _impl_.type_.ClearToEmpty();
1646 }
type()1647 inline const std::string& OpDef_AttrDef::type() const {
1648 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.type)
1649 return _internal_type();
1650 }
1651 template <typename ArgT0, typename... ArgT>
1652 inline PROTOBUF_ALWAYS_INLINE
set_type(ArgT0 && arg0,ArgT...args)1653 void OpDef_AttrDef::set_type(ArgT0&& arg0, ArgT... args) {
1654
1655 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1656 // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.type)
1657 }
mutable_type()1658 inline std::string* OpDef_AttrDef::mutable_type() {
1659 std::string* _s = _internal_mutable_type();
1660 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.type)
1661 return _s;
1662 }
_internal_type()1663 inline const std::string& OpDef_AttrDef::_internal_type() const {
1664 return _impl_.type_.Get();
1665 }
_internal_set_type(const std::string & value)1666 inline void OpDef_AttrDef::_internal_set_type(const std::string& value) {
1667
1668 _impl_.type_.Set(value, GetArenaForAllocation());
1669 }
_internal_mutable_type()1670 inline std::string* OpDef_AttrDef::_internal_mutable_type() {
1671
1672 return _impl_.type_.Mutable(GetArenaForAllocation());
1673 }
release_type()1674 inline std::string* OpDef_AttrDef::release_type() {
1675 // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.type)
1676 return _impl_.type_.Release();
1677 }
set_allocated_type(std::string * type)1678 inline void OpDef_AttrDef::set_allocated_type(std::string* type) {
1679 _impl_.type_.SetAllocated(type, GetArenaForAllocation());
1680 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1681 if (_impl_.type_.IsDefault()) {
1682 _impl_.type_.Set("", GetArenaForAllocation());
1683 }
1684 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1685 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.type)
1686 }
1687
1688 // .tensorflow.AttrValue default_value = 3;
_internal_has_default_value()1689 inline bool OpDef_AttrDef::_internal_has_default_value() const {
1690 return this != internal_default_instance() && _impl_.default_value_ != nullptr;
1691 }
has_default_value()1692 inline bool OpDef_AttrDef::has_default_value() const {
1693 return _internal_has_default_value();
1694 }
_internal_default_value()1695 inline const ::tensorflow::AttrValue& OpDef_AttrDef::_internal_default_value() const {
1696 const ::tensorflow::AttrValue* p = _impl_.default_value_;
1697 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
1698 ::tensorflow::_AttrValue_default_instance_);
1699 }
default_value()1700 inline const ::tensorflow::AttrValue& OpDef_AttrDef::default_value() const {
1701 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.default_value)
1702 return _internal_default_value();
1703 }
unsafe_arena_set_allocated_default_value(::tensorflow::AttrValue * default_value)1704 inline void OpDef_AttrDef::unsafe_arena_set_allocated_default_value(
1705 ::tensorflow::AttrValue* default_value) {
1706 if (GetArenaForAllocation() == nullptr) {
1707 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
1708 }
1709 _impl_.default_value_ = default_value;
1710 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.default_value)
1711 }
release_default_value()1712 inline ::tensorflow::AttrValue* OpDef_AttrDef::release_default_value() {
1713
1714 ::tensorflow::AttrValue* temp = _impl_.default_value_;
1715 _impl_.default_value_ = nullptr;
1716 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1717 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1718 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1719 if (GetArenaForAllocation() == nullptr) { delete old; }
1720 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1721 if (GetArenaForAllocation() != nullptr) {
1722 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1723 }
1724 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1725 return temp;
1726 }
unsafe_arena_release_default_value()1727 inline ::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_default_value() {
1728 // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.default_value)
1729
1730 ::tensorflow::AttrValue* temp = _impl_.default_value_;
1731 _impl_.default_value_ = nullptr;
1732 return temp;
1733 }
_internal_mutable_default_value()1734 inline ::tensorflow::AttrValue* OpDef_AttrDef::_internal_mutable_default_value() {
1735
1736 if (_impl_.default_value_ == nullptr) {
1737 auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
1738 _impl_.default_value_ = p;
1739 }
1740 return _impl_.default_value_;
1741 }
mutable_default_value()1742 inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_default_value() {
1743 ::tensorflow::AttrValue* _msg = _internal_mutable_default_value();
1744 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.default_value)
1745 return _msg;
1746 }
set_allocated_default_value(::tensorflow::AttrValue * default_value)1747 inline void OpDef_AttrDef::set_allocated_default_value(::tensorflow::AttrValue* default_value) {
1748 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1749 if (message_arena == nullptr) {
1750 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.default_value_);
1751 }
1752 if (default_value) {
1753 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1754 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1755 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_value));
1756 if (message_arena != submessage_arena) {
1757 default_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1758 message_arena, default_value, submessage_arena);
1759 }
1760
1761 } else {
1762
1763 }
1764 _impl_.default_value_ = default_value;
1765 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.default_value)
1766 }
1767
1768 // string description = 4;
clear_description()1769 inline void OpDef_AttrDef::clear_description() {
1770 _impl_.description_.ClearToEmpty();
1771 }
description()1772 inline const std::string& OpDef_AttrDef::description() const {
1773 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.description)
1774 return _internal_description();
1775 }
1776 template <typename ArgT0, typename... ArgT>
1777 inline PROTOBUF_ALWAYS_INLINE
set_description(ArgT0 && arg0,ArgT...args)1778 void OpDef_AttrDef::set_description(ArgT0&& arg0, ArgT... args) {
1779
1780 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1781 // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.description)
1782 }
mutable_description()1783 inline std::string* OpDef_AttrDef::mutable_description() {
1784 std::string* _s = _internal_mutable_description();
1785 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.description)
1786 return _s;
1787 }
_internal_description()1788 inline const std::string& OpDef_AttrDef::_internal_description() const {
1789 return _impl_.description_.Get();
1790 }
_internal_set_description(const std::string & value)1791 inline void OpDef_AttrDef::_internal_set_description(const std::string& value) {
1792
1793 _impl_.description_.Set(value, GetArenaForAllocation());
1794 }
_internal_mutable_description()1795 inline std::string* OpDef_AttrDef::_internal_mutable_description() {
1796
1797 return _impl_.description_.Mutable(GetArenaForAllocation());
1798 }
release_description()1799 inline std::string* OpDef_AttrDef::release_description() {
1800 // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.description)
1801 return _impl_.description_.Release();
1802 }
set_allocated_description(std::string * description)1803 inline void OpDef_AttrDef::set_allocated_description(std::string* description) {
1804 _impl_.description_.SetAllocated(description, GetArenaForAllocation());
1805 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1806 if (_impl_.description_.IsDefault()) {
1807 _impl_.description_.Set("", GetArenaForAllocation());
1808 }
1809 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1810 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.description)
1811 }
1812
1813 // bool has_minimum = 5;
clear_has_minimum()1814 inline void OpDef_AttrDef::clear_has_minimum() {
1815 _impl_.has_minimum_ = false;
1816 }
_internal_has_minimum()1817 inline bool OpDef_AttrDef::_internal_has_minimum() const {
1818 return _impl_.has_minimum_;
1819 }
has_minimum()1820 inline bool OpDef_AttrDef::has_minimum() const {
1821 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.has_minimum)
1822 return _internal_has_minimum();
1823 }
_internal_set_has_minimum(bool value)1824 inline void OpDef_AttrDef::_internal_set_has_minimum(bool value) {
1825
1826 _impl_.has_minimum_ = value;
1827 }
set_has_minimum(bool value)1828 inline void OpDef_AttrDef::set_has_minimum(bool value) {
1829 _internal_set_has_minimum(value);
1830 // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.has_minimum)
1831 }
1832
1833 // int64 minimum = 6;
clear_minimum()1834 inline void OpDef_AttrDef::clear_minimum() {
1835 _impl_.minimum_ = ::int64_t{0};
1836 }
_internal_minimum()1837 inline ::int64_t OpDef_AttrDef::_internal_minimum() const {
1838 return _impl_.minimum_;
1839 }
minimum()1840 inline ::int64_t OpDef_AttrDef::minimum() const {
1841 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.minimum)
1842 return _internal_minimum();
1843 }
_internal_set_minimum(::int64_t value)1844 inline void OpDef_AttrDef::_internal_set_minimum(::int64_t value) {
1845
1846 _impl_.minimum_ = value;
1847 }
set_minimum(::int64_t value)1848 inline void OpDef_AttrDef::set_minimum(::int64_t value) {
1849 _internal_set_minimum(value);
1850 // @@protoc_insertion_point(field_set:tensorflow.OpDef.AttrDef.minimum)
1851 }
1852
1853 // .tensorflow.AttrValue allowed_values = 7;
_internal_has_allowed_values()1854 inline bool OpDef_AttrDef::_internal_has_allowed_values() const {
1855 return this != internal_default_instance() && _impl_.allowed_values_ != nullptr;
1856 }
has_allowed_values()1857 inline bool OpDef_AttrDef::has_allowed_values() const {
1858 return _internal_has_allowed_values();
1859 }
_internal_allowed_values()1860 inline const ::tensorflow::AttrValue& OpDef_AttrDef::_internal_allowed_values() const {
1861 const ::tensorflow::AttrValue* p = _impl_.allowed_values_;
1862 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::AttrValue&>(
1863 ::tensorflow::_AttrValue_default_instance_);
1864 }
allowed_values()1865 inline const ::tensorflow::AttrValue& OpDef_AttrDef::allowed_values() const {
1866 // @@protoc_insertion_point(field_get:tensorflow.OpDef.AttrDef.allowed_values)
1867 return _internal_allowed_values();
1868 }
unsafe_arena_set_allocated_allowed_values(::tensorflow::AttrValue * allowed_values)1869 inline void OpDef_AttrDef::unsafe_arena_set_allocated_allowed_values(
1870 ::tensorflow::AttrValue* allowed_values) {
1871 if (GetArenaForAllocation() == nullptr) {
1872 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
1873 }
1874 _impl_.allowed_values_ = allowed_values;
1875 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.AttrDef.allowed_values)
1876 }
release_allowed_values()1877 inline ::tensorflow::AttrValue* OpDef_AttrDef::release_allowed_values() {
1878
1879 ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
1880 _impl_.allowed_values_ = nullptr;
1881 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1882 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1883 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1884 if (GetArenaForAllocation() == nullptr) { delete old; }
1885 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1886 if (GetArenaForAllocation() != nullptr) {
1887 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1888 }
1889 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1890 return temp;
1891 }
unsafe_arena_release_allowed_values()1892 inline ::tensorflow::AttrValue* OpDef_AttrDef::unsafe_arena_release_allowed_values() {
1893 // @@protoc_insertion_point(field_release:tensorflow.OpDef.AttrDef.allowed_values)
1894
1895 ::tensorflow::AttrValue* temp = _impl_.allowed_values_;
1896 _impl_.allowed_values_ = nullptr;
1897 return temp;
1898 }
_internal_mutable_allowed_values()1899 inline ::tensorflow::AttrValue* OpDef_AttrDef::_internal_mutable_allowed_values() {
1900
1901 if (_impl_.allowed_values_ == nullptr) {
1902 auto* p = CreateMaybeMessage<::tensorflow::AttrValue>(GetArenaForAllocation());
1903 _impl_.allowed_values_ = p;
1904 }
1905 return _impl_.allowed_values_;
1906 }
mutable_allowed_values()1907 inline ::tensorflow::AttrValue* OpDef_AttrDef::mutable_allowed_values() {
1908 ::tensorflow::AttrValue* _msg = _internal_mutable_allowed_values();
1909 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.AttrDef.allowed_values)
1910 return _msg;
1911 }
set_allocated_allowed_values(::tensorflow::AttrValue * allowed_values)1912 inline void OpDef_AttrDef::set_allocated_allowed_values(::tensorflow::AttrValue* allowed_values) {
1913 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1914 if (message_arena == nullptr) {
1915 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.allowed_values_);
1916 }
1917 if (allowed_values) {
1918 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1919 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1920 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(allowed_values));
1921 if (message_arena != submessage_arena) {
1922 allowed_values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1923 message_arena, allowed_values, submessage_arena);
1924 }
1925
1926 } else {
1927
1928 }
1929 _impl_.allowed_values_ = allowed_values;
1930 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.AttrDef.allowed_values)
1931 }
1932
1933 // -------------------------------------------------------------------
1934
1935 // OpDef
1936
1937 // string name = 1;
clear_name()1938 inline void OpDef::clear_name() {
1939 _impl_.name_.ClearToEmpty();
1940 }
name()1941 inline const std::string& OpDef::name() const {
1942 // @@protoc_insertion_point(field_get:tensorflow.OpDef.name)
1943 return _internal_name();
1944 }
1945 template <typename ArgT0, typename... ArgT>
1946 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1947 void OpDef::set_name(ArgT0&& arg0, ArgT... args) {
1948
1949 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1950 // @@protoc_insertion_point(field_set:tensorflow.OpDef.name)
1951 }
mutable_name()1952 inline std::string* OpDef::mutable_name() {
1953 std::string* _s = _internal_mutable_name();
1954 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.name)
1955 return _s;
1956 }
_internal_name()1957 inline const std::string& OpDef::_internal_name() const {
1958 return _impl_.name_.Get();
1959 }
_internal_set_name(const std::string & value)1960 inline void OpDef::_internal_set_name(const std::string& value) {
1961
1962 _impl_.name_.Set(value, GetArenaForAllocation());
1963 }
_internal_mutable_name()1964 inline std::string* OpDef::_internal_mutable_name() {
1965
1966 return _impl_.name_.Mutable(GetArenaForAllocation());
1967 }
release_name()1968 inline std::string* OpDef::release_name() {
1969 // @@protoc_insertion_point(field_release:tensorflow.OpDef.name)
1970 return _impl_.name_.Release();
1971 }
set_allocated_name(std::string * name)1972 inline void OpDef::set_allocated_name(std::string* name) {
1973 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1974 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1975 if (_impl_.name_.IsDefault()) {
1976 _impl_.name_.Set("", GetArenaForAllocation());
1977 }
1978 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1979 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.name)
1980 }
1981
1982 // repeated .tensorflow.OpDef.ArgDef input_arg = 2;
_internal_input_arg_size()1983 inline int OpDef::_internal_input_arg_size() const {
1984 return _impl_.input_arg_.size();
1985 }
input_arg_size()1986 inline int OpDef::input_arg_size() const {
1987 return _internal_input_arg_size();
1988 }
clear_input_arg()1989 inline void OpDef::clear_input_arg() {
1990 _impl_.input_arg_.Clear();
1991 }
mutable_input_arg(int index)1992 inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_input_arg(int index) {
1993 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.input_arg)
1994 return _impl_.input_arg_.Mutable(index);
1995 }
1996 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
mutable_input_arg()1997 OpDef::mutable_input_arg() {
1998 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.input_arg)
1999 return &_impl_.input_arg_;
2000 }
_internal_input_arg(int index)2001 inline const ::tensorflow::OpDef_ArgDef& OpDef::_internal_input_arg(int index) const {
2002 return _impl_.input_arg_.Get(index);
2003 }
input_arg(int index)2004 inline const ::tensorflow::OpDef_ArgDef& OpDef::input_arg(int index) const {
2005 // @@protoc_insertion_point(field_get:tensorflow.OpDef.input_arg)
2006 return _internal_input_arg(index);
2007 }
_internal_add_input_arg()2008 inline ::tensorflow::OpDef_ArgDef* OpDef::_internal_add_input_arg() {
2009 return _impl_.input_arg_.Add();
2010 }
add_input_arg()2011 inline ::tensorflow::OpDef_ArgDef* OpDef::add_input_arg() {
2012 ::tensorflow::OpDef_ArgDef* _add = _internal_add_input_arg();
2013 // @@protoc_insertion_point(field_add:tensorflow.OpDef.input_arg)
2014 return _add;
2015 }
2016 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
input_arg()2017 OpDef::input_arg() const {
2018 // @@protoc_insertion_point(field_list:tensorflow.OpDef.input_arg)
2019 return _impl_.input_arg_;
2020 }
2021
2022 // repeated .tensorflow.OpDef.ArgDef output_arg = 3;
_internal_output_arg_size()2023 inline int OpDef::_internal_output_arg_size() const {
2024 return _impl_.output_arg_.size();
2025 }
output_arg_size()2026 inline int OpDef::output_arg_size() const {
2027 return _internal_output_arg_size();
2028 }
clear_output_arg()2029 inline void OpDef::clear_output_arg() {
2030 _impl_.output_arg_.Clear();
2031 }
mutable_output_arg(int index)2032 inline ::tensorflow::OpDef_ArgDef* OpDef::mutable_output_arg(int index) {
2033 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.output_arg)
2034 return _impl_.output_arg_.Mutable(index);
2035 }
2036 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >*
mutable_output_arg()2037 OpDef::mutable_output_arg() {
2038 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.output_arg)
2039 return &_impl_.output_arg_;
2040 }
_internal_output_arg(int index)2041 inline const ::tensorflow::OpDef_ArgDef& OpDef::_internal_output_arg(int index) const {
2042 return _impl_.output_arg_.Get(index);
2043 }
output_arg(int index)2044 inline const ::tensorflow::OpDef_ArgDef& OpDef::output_arg(int index) const {
2045 // @@protoc_insertion_point(field_get:tensorflow.OpDef.output_arg)
2046 return _internal_output_arg(index);
2047 }
_internal_add_output_arg()2048 inline ::tensorflow::OpDef_ArgDef* OpDef::_internal_add_output_arg() {
2049 return _impl_.output_arg_.Add();
2050 }
add_output_arg()2051 inline ::tensorflow::OpDef_ArgDef* OpDef::add_output_arg() {
2052 ::tensorflow::OpDef_ArgDef* _add = _internal_add_output_arg();
2053 // @@protoc_insertion_point(field_add:tensorflow.OpDef.output_arg)
2054 return _add;
2055 }
2056 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_ArgDef >&
output_arg()2057 OpDef::output_arg() const {
2058 // @@protoc_insertion_point(field_list:tensorflow.OpDef.output_arg)
2059 return _impl_.output_arg_;
2060 }
2061
2062 // repeated string control_output = 20;
_internal_control_output_size()2063 inline int OpDef::_internal_control_output_size() const {
2064 return _impl_.control_output_.size();
2065 }
control_output_size()2066 inline int OpDef::control_output_size() const {
2067 return _internal_control_output_size();
2068 }
clear_control_output()2069 inline void OpDef::clear_control_output() {
2070 _impl_.control_output_.Clear();
2071 }
add_control_output()2072 inline std::string* OpDef::add_control_output() {
2073 std::string* _s = _internal_add_control_output();
2074 // @@protoc_insertion_point(field_add_mutable:tensorflow.OpDef.control_output)
2075 return _s;
2076 }
_internal_control_output(int index)2077 inline const std::string& OpDef::_internal_control_output(int index) const {
2078 return _impl_.control_output_.Get(index);
2079 }
control_output(int index)2080 inline const std::string& OpDef::control_output(int index) const {
2081 // @@protoc_insertion_point(field_get:tensorflow.OpDef.control_output)
2082 return _internal_control_output(index);
2083 }
mutable_control_output(int index)2084 inline std::string* OpDef::mutable_control_output(int index) {
2085 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.control_output)
2086 return _impl_.control_output_.Mutable(index);
2087 }
set_control_output(int index,const std::string & value)2088 inline void OpDef::set_control_output(int index, const std::string& value) {
2089 _impl_.control_output_.Mutable(index)->assign(value);
2090 // @@protoc_insertion_point(field_set:tensorflow.OpDef.control_output)
2091 }
set_control_output(int index,std::string && value)2092 inline void OpDef::set_control_output(int index, std::string&& value) {
2093 _impl_.control_output_.Mutable(index)->assign(std::move(value));
2094 // @@protoc_insertion_point(field_set:tensorflow.OpDef.control_output)
2095 }
set_control_output(int index,const char * value)2096 inline void OpDef::set_control_output(int index, const char* value) {
2097 GOOGLE_DCHECK(value != nullptr);
2098 _impl_.control_output_.Mutable(index)->assign(value);
2099 // @@protoc_insertion_point(field_set_char:tensorflow.OpDef.control_output)
2100 }
set_control_output(int index,const char * value,size_t size)2101 inline void OpDef::set_control_output(int index, const char* value, size_t size) {
2102 _impl_.control_output_.Mutable(index)->assign(
2103 reinterpret_cast<const char*>(value), size);
2104 // @@protoc_insertion_point(field_set_pointer:tensorflow.OpDef.control_output)
2105 }
_internal_add_control_output()2106 inline std::string* OpDef::_internal_add_control_output() {
2107 return _impl_.control_output_.Add();
2108 }
add_control_output(const std::string & value)2109 inline void OpDef::add_control_output(const std::string& value) {
2110 _impl_.control_output_.Add()->assign(value);
2111 // @@protoc_insertion_point(field_add:tensorflow.OpDef.control_output)
2112 }
add_control_output(std::string && value)2113 inline void OpDef::add_control_output(std::string&& value) {
2114 _impl_.control_output_.Add(std::move(value));
2115 // @@protoc_insertion_point(field_add:tensorflow.OpDef.control_output)
2116 }
add_control_output(const char * value)2117 inline void OpDef::add_control_output(const char* value) {
2118 GOOGLE_DCHECK(value != nullptr);
2119 _impl_.control_output_.Add()->assign(value);
2120 // @@protoc_insertion_point(field_add_char:tensorflow.OpDef.control_output)
2121 }
add_control_output(const char * value,size_t size)2122 inline void OpDef::add_control_output(const char* value, size_t size) {
2123 _impl_.control_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
2124 // @@protoc_insertion_point(field_add_pointer:tensorflow.OpDef.control_output)
2125 }
2126 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
control_output()2127 OpDef::control_output() const {
2128 // @@protoc_insertion_point(field_list:tensorflow.OpDef.control_output)
2129 return _impl_.control_output_;
2130 }
2131 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_control_output()2132 OpDef::mutable_control_output() {
2133 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.control_output)
2134 return &_impl_.control_output_;
2135 }
2136
2137 // repeated .tensorflow.OpDef.AttrDef attr = 4;
_internal_attr_size()2138 inline int OpDef::_internal_attr_size() const {
2139 return _impl_.attr_.size();
2140 }
attr_size()2141 inline int OpDef::attr_size() const {
2142 return _internal_attr_size();
2143 }
clear_attr()2144 inline void OpDef::clear_attr() {
2145 _impl_.attr_.Clear();
2146 }
mutable_attr(int index)2147 inline ::tensorflow::OpDef_AttrDef* OpDef::mutable_attr(int index) {
2148 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.attr)
2149 return _impl_.attr_.Mutable(index);
2150 }
2151 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >*
mutable_attr()2152 OpDef::mutable_attr() {
2153 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpDef.attr)
2154 return &_impl_.attr_;
2155 }
_internal_attr(int index)2156 inline const ::tensorflow::OpDef_AttrDef& OpDef::_internal_attr(int index) const {
2157 return _impl_.attr_.Get(index);
2158 }
attr(int index)2159 inline const ::tensorflow::OpDef_AttrDef& OpDef::attr(int index) const {
2160 // @@protoc_insertion_point(field_get:tensorflow.OpDef.attr)
2161 return _internal_attr(index);
2162 }
_internal_add_attr()2163 inline ::tensorflow::OpDef_AttrDef* OpDef::_internal_add_attr() {
2164 return _impl_.attr_.Add();
2165 }
add_attr()2166 inline ::tensorflow::OpDef_AttrDef* OpDef::add_attr() {
2167 ::tensorflow::OpDef_AttrDef* _add = _internal_add_attr();
2168 // @@protoc_insertion_point(field_add:tensorflow.OpDef.attr)
2169 return _add;
2170 }
2171 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef_AttrDef >&
attr()2172 OpDef::attr() const {
2173 // @@protoc_insertion_point(field_list:tensorflow.OpDef.attr)
2174 return _impl_.attr_;
2175 }
2176
2177 // .tensorflow.OpDeprecation deprecation = 8;
_internal_has_deprecation()2178 inline bool OpDef::_internal_has_deprecation() const {
2179 return this != internal_default_instance() && _impl_.deprecation_ != nullptr;
2180 }
has_deprecation()2181 inline bool OpDef::has_deprecation() const {
2182 return _internal_has_deprecation();
2183 }
clear_deprecation()2184 inline void OpDef::clear_deprecation() {
2185 if (GetArenaForAllocation() == nullptr && _impl_.deprecation_ != nullptr) {
2186 delete _impl_.deprecation_;
2187 }
2188 _impl_.deprecation_ = nullptr;
2189 }
_internal_deprecation()2190 inline const ::tensorflow::OpDeprecation& OpDef::_internal_deprecation() const {
2191 const ::tensorflow::OpDeprecation* p = _impl_.deprecation_;
2192 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::OpDeprecation&>(
2193 ::tensorflow::_OpDeprecation_default_instance_);
2194 }
deprecation()2195 inline const ::tensorflow::OpDeprecation& OpDef::deprecation() const {
2196 // @@protoc_insertion_point(field_get:tensorflow.OpDef.deprecation)
2197 return _internal_deprecation();
2198 }
unsafe_arena_set_allocated_deprecation(::tensorflow::OpDeprecation * deprecation)2199 inline void OpDef::unsafe_arena_set_allocated_deprecation(
2200 ::tensorflow::OpDeprecation* deprecation) {
2201 if (GetArenaForAllocation() == nullptr) {
2202 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deprecation_);
2203 }
2204 _impl_.deprecation_ = deprecation;
2205 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.OpDef.deprecation)
2206 }
release_deprecation()2207 inline ::tensorflow::OpDeprecation* OpDef::release_deprecation() {
2208
2209 ::tensorflow::OpDeprecation* temp = _impl_.deprecation_;
2210 _impl_.deprecation_ = nullptr;
2211 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2212 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2213 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2214 if (GetArenaForAllocation() == nullptr) { delete old; }
2215 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2216 if (GetArenaForAllocation() != nullptr) {
2217 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2218 }
2219 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2220 return temp;
2221 }
unsafe_arena_release_deprecation()2222 inline ::tensorflow::OpDeprecation* OpDef::unsafe_arena_release_deprecation() {
2223 // @@protoc_insertion_point(field_release:tensorflow.OpDef.deprecation)
2224
2225 ::tensorflow::OpDeprecation* temp = _impl_.deprecation_;
2226 _impl_.deprecation_ = nullptr;
2227 return temp;
2228 }
_internal_mutable_deprecation()2229 inline ::tensorflow::OpDeprecation* OpDef::_internal_mutable_deprecation() {
2230
2231 if (_impl_.deprecation_ == nullptr) {
2232 auto* p = CreateMaybeMessage<::tensorflow::OpDeprecation>(GetArenaForAllocation());
2233 _impl_.deprecation_ = p;
2234 }
2235 return _impl_.deprecation_;
2236 }
mutable_deprecation()2237 inline ::tensorflow::OpDeprecation* OpDef::mutable_deprecation() {
2238 ::tensorflow::OpDeprecation* _msg = _internal_mutable_deprecation();
2239 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.deprecation)
2240 return _msg;
2241 }
set_allocated_deprecation(::tensorflow::OpDeprecation * deprecation)2242 inline void OpDef::set_allocated_deprecation(::tensorflow::OpDeprecation* deprecation) {
2243 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2244 if (message_arena == nullptr) {
2245 delete _impl_.deprecation_;
2246 }
2247 if (deprecation) {
2248 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2249 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deprecation);
2250 if (message_arena != submessage_arena) {
2251 deprecation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2252 message_arena, deprecation, submessage_arena);
2253 }
2254
2255 } else {
2256
2257 }
2258 _impl_.deprecation_ = deprecation;
2259 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.deprecation)
2260 }
2261
2262 // string summary = 5;
clear_summary()2263 inline void OpDef::clear_summary() {
2264 _impl_.summary_.ClearToEmpty();
2265 }
summary()2266 inline const std::string& OpDef::summary() const {
2267 // @@protoc_insertion_point(field_get:tensorflow.OpDef.summary)
2268 return _internal_summary();
2269 }
2270 template <typename ArgT0, typename... ArgT>
2271 inline PROTOBUF_ALWAYS_INLINE
set_summary(ArgT0 && arg0,ArgT...args)2272 void OpDef::set_summary(ArgT0&& arg0, ArgT... args) {
2273
2274 _impl_.summary_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2275 // @@protoc_insertion_point(field_set:tensorflow.OpDef.summary)
2276 }
mutable_summary()2277 inline std::string* OpDef::mutable_summary() {
2278 std::string* _s = _internal_mutable_summary();
2279 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.summary)
2280 return _s;
2281 }
_internal_summary()2282 inline const std::string& OpDef::_internal_summary() const {
2283 return _impl_.summary_.Get();
2284 }
_internal_set_summary(const std::string & value)2285 inline void OpDef::_internal_set_summary(const std::string& value) {
2286
2287 _impl_.summary_.Set(value, GetArenaForAllocation());
2288 }
_internal_mutable_summary()2289 inline std::string* OpDef::_internal_mutable_summary() {
2290
2291 return _impl_.summary_.Mutable(GetArenaForAllocation());
2292 }
release_summary()2293 inline std::string* OpDef::release_summary() {
2294 // @@protoc_insertion_point(field_release:tensorflow.OpDef.summary)
2295 return _impl_.summary_.Release();
2296 }
set_allocated_summary(std::string * summary)2297 inline void OpDef::set_allocated_summary(std::string* summary) {
2298 _impl_.summary_.SetAllocated(summary, GetArenaForAllocation());
2299 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2300 if (_impl_.summary_.IsDefault()) {
2301 _impl_.summary_.Set("", GetArenaForAllocation());
2302 }
2303 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2304 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.summary)
2305 }
2306
2307 // string description = 6;
clear_description()2308 inline void OpDef::clear_description() {
2309 _impl_.description_.ClearToEmpty();
2310 }
description()2311 inline const std::string& OpDef::description() const {
2312 // @@protoc_insertion_point(field_get:tensorflow.OpDef.description)
2313 return _internal_description();
2314 }
2315 template <typename ArgT0, typename... ArgT>
2316 inline PROTOBUF_ALWAYS_INLINE
set_description(ArgT0 && arg0,ArgT...args)2317 void OpDef::set_description(ArgT0&& arg0, ArgT... args) {
2318
2319 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2320 // @@protoc_insertion_point(field_set:tensorflow.OpDef.description)
2321 }
mutable_description()2322 inline std::string* OpDef::mutable_description() {
2323 std::string* _s = _internal_mutable_description();
2324 // @@protoc_insertion_point(field_mutable:tensorflow.OpDef.description)
2325 return _s;
2326 }
_internal_description()2327 inline const std::string& OpDef::_internal_description() const {
2328 return _impl_.description_.Get();
2329 }
_internal_set_description(const std::string & value)2330 inline void OpDef::_internal_set_description(const std::string& value) {
2331
2332 _impl_.description_.Set(value, GetArenaForAllocation());
2333 }
_internal_mutable_description()2334 inline std::string* OpDef::_internal_mutable_description() {
2335
2336 return _impl_.description_.Mutable(GetArenaForAllocation());
2337 }
release_description()2338 inline std::string* OpDef::release_description() {
2339 // @@protoc_insertion_point(field_release:tensorflow.OpDef.description)
2340 return _impl_.description_.Release();
2341 }
set_allocated_description(std::string * description)2342 inline void OpDef::set_allocated_description(std::string* description) {
2343 _impl_.description_.SetAllocated(description, GetArenaForAllocation());
2344 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2345 if (_impl_.description_.IsDefault()) {
2346 _impl_.description_.Set("", GetArenaForAllocation());
2347 }
2348 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2349 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDef.description)
2350 }
2351
2352 // bool is_commutative = 18;
clear_is_commutative()2353 inline void OpDef::clear_is_commutative() {
2354 _impl_.is_commutative_ = false;
2355 }
_internal_is_commutative()2356 inline bool OpDef::_internal_is_commutative() const {
2357 return _impl_.is_commutative_;
2358 }
is_commutative()2359 inline bool OpDef::is_commutative() const {
2360 // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_commutative)
2361 return _internal_is_commutative();
2362 }
_internal_set_is_commutative(bool value)2363 inline void OpDef::_internal_set_is_commutative(bool value) {
2364
2365 _impl_.is_commutative_ = value;
2366 }
set_is_commutative(bool value)2367 inline void OpDef::set_is_commutative(bool value) {
2368 _internal_set_is_commutative(value);
2369 // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_commutative)
2370 }
2371
2372 // bool is_aggregate = 16;
clear_is_aggregate()2373 inline void OpDef::clear_is_aggregate() {
2374 _impl_.is_aggregate_ = false;
2375 }
_internal_is_aggregate()2376 inline bool OpDef::_internal_is_aggregate() const {
2377 return _impl_.is_aggregate_;
2378 }
is_aggregate()2379 inline bool OpDef::is_aggregate() const {
2380 // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_aggregate)
2381 return _internal_is_aggregate();
2382 }
_internal_set_is_aggregate(bool value)2383 inline void OpDef::_internal_set_is_aggregate(bool value) {
2384
2385 _impl_.is_aggregate_ = value;
2386 }
set_is_aggregate(bool value)2387 inline void OpDef::set_is_aggregate(bool value) {
2388 _internal_set_is_aggregate(value);
2389 // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_aggregate)
2390 }
2391
2392 // bool is_stateful = 17;
clear_is_stateful()2393 inline void OpDef::clear_is_stateful() {
2394 _impl_.is_stateful_ = false;
2395 }
_internal_is_stateful()2396 inline bool OpDef::_internal_is_stateful() const {
2397 return _impl_.is_stateful_;
2398 }
is_stateful()2399 inline bool OpDef::is_stateful() const {
2400 // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_stateful)
2401 return _internal_is_stateful();
2402 }
_internal_set_is_stateful(bool value)2403 inline void OpDef::_internal_set_is_stateful(bool value) {
2404
2405 _impl_.is_stateful_ = value;
2406 }
set_is_stateful(bool value)2407 inline void OpDef::set_is_stateful(bool value) {
2408 _internal_set_is_stateful(value);
2409 // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_stateful)
2410 }
2411
2412 // bool allows_uninitialized_input = 19;
clear_allows_uninitialized_input()2413 inline void OpDef::clear_allows_uninitialized_input() {
2414 _impl_.allows_uninitialized_input_ = false;
2415 }
_internal_allows_uninitialized_input()2416 inline bool OpDef::_internal_allows_uninitialized_input() const {
2417 return _impl_.allows_uninitialized_input_;
2418 }
allows_uninitialized_input()2419 inline bool OpDef::allows_uninitialized_input() const {
2420 // @@protoc_insertion_point(field_get:tensorflow.OpDef.allows_uninitialized_input)
2421 return _internal_allows_uninitialized_input();
2422 }
_internal_set_allows_uninitialized_input(bool value)2423 inline void OpDef::_internal_set_allows_uninitialized_input(bool value) {
2424
2425 _impl_.allows_uninitialized_input_ = value;
2426 }
set_allows_uninitialized_input(bool value)2427 inline void OpDef::set_allows_uninitialized_input(bool value) {
2428 _internal_set_allows_uninitialized_input(value);
2429 // @@protoc_insertion_point(field_set:tensorflow.OpDef.allows_uninitialized_input)
2430 }
2431
2432 // bool is_distributed_communication = 21;
clear_is_distributed_communication()2433 inline void OpDef::clear_is_distributed_communication() {
2434 _impl_.is_distributed_communication_ = false;
2435 }
_internal_is_distributed_communication()2436 inline bool OpDef::_internal_is_distributed_communication() const {
2437 return _impl_.is_distributed_communication_;
2438 }
is_distributed_communication()2439 inline bool OpDef::is_distributed_communication() const {
2440 // @@protoc_insertion_point(field_get:tensorflow.OpDef.is_distributed_communication)
2441 return _internal_is_distributed_communication();
2442 }
_internal_set_is_distributed_communication(bool value)2443 inline void OpDef::_internal_set_is_distributed_communication(bool value) {
2444
2445 _impl_.is_distributed_communication_ = value;
2446 }
set_is_distributed_communication(bool value)2447 inline void OpDef::set_is_distributed_communication(bool value) {
2448 _internal_set_is_distributed_communication(value);
2449 // @@protoc_insertion_point(field_set:tensorflow.OpDef.is_distributed_communication)
2450 }
2451
2452 // -------------------------------------------------------------------
2453
2454 // OpDeprecation
2455
2456 // int32 version = 1;
clear_version()2457 inline void OpDeprecation::clear_version() {
2458 _impl_.version_ = 0;
2459 }
_internal_version()2460 inline ::int32_t OpDeprecation::_internal_version() const {
2461 return _impl_.version_;
2462 }
version()2463 inline ::int32_t OpDeprecation::version() const {
2464 // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.version)
2465 return _internal_version();
2466 }
_internal_set_version(::int32_t value)2467 inline void OpDeprecation::_internal_set_version(::int32_t value) {
2468
2469 _impl_.version_ = value;
2470 }
set_version(::int32_t value)2471 inline void OpDeprecation::set_version(::int32_t value) {
2472 _internal_set_version(value);
2473 // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.version)
2474 }
2475
2476 // string explanation = 2;
clear_explanation()2477 inline void OpDeprecation::clear_explanation() {
2478 _impl_.explanation_.ClearToEmpty();
2479 }
explanation()2480 inline const std::string& OpDeprecation::explanation() const {
2481 // @@protoc_insertion_point(field_get:tensorflow.OpDeprecation.explanation)
2482 return _internal_explanation();
2483 }
2484 template <typename ArgT0, typename... ArgT>
2485 inline PROTOBUF_ALWAYS_INLINE
set_explanation(ArgT0 && arg0,ArgT...args)2486 void OpDeprecation::set_explanation(ArgT0&& arg0, ArgT... args) {
2487
2488 _impl_.explanation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2489 // @@protoc_insertion_point(field_set:tensorflow.OpDeprecation.explanation)
2490 }
mutable_explanation()2491 inline std::string* OpDeprecation::mutable_explanation() {
2492 std::string* _s = _internal_mutable_explanation();
2493 // @@protoc_insertion_point(field_mutable:tensorflow.OpDeprecation.explanation)
2494 return _s;
2495 }
_internal_explanation()2496 inline const std::string& OpDeprecation::_internal_explanation() const {
2497 return _impl_.explanation_.Get();
2498 }
_internal_set_explanation(const std::string & value)2499 inline void OpDeprecation::_internal_set_explanation(const std::string& value) {
2500
2501 _impl_.explanation_.Set(value, GetArenaForAllocation());
2502 }
_internal_mutable_explanation()2503 inline std::string* OpDeprecation::_internal_mutable_explanation() {
2504
2505 return _impl_.explanation_.Mutable(GetArenaForAllocation());
2506 }
release_explanation()2507 inline std::string* OpDeprecation::release_explanation() {
2508 // @@protoc_insertion_point(field_release:tensorflow.OpDeprecation.explanation)
2509 return _impl_.explanation_.Release();
2510 }
set_allocated_explanation(std::string * explanation)2511 inline void OpDeprecation::set_allocated_explanation(std::string* explanation) {
2512 _impl_.explanation_.SetAllocated(explanation, GetArenaForAllocation());
2513 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2514 if (_impl_.explanation_.IsDefault()) {
2515 _impl_.explanation_.Set("", GetArenaForAllocation());
2516 }
2517 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2518 // @@protoc_insertion_point(field_set_allocated:tensorflow.OpDeprecation.explanation)
2519 }
2520
2521 // -------------------------------------------------------------------
2522
2523 // OpList
2524
2525 // repeated .tensorflow.OpDef op = 1;
_internal_op_size()2526 inline int OpList::_internal_op_size() const {
2527 return _impl_.op_.size();
2528 }
op_size()2529 inline int OpList::op_size() const {
2530 return _internal_op_size();
2531 }
clear_op()2532 inline void OpList::clear_op() {
2533 _impl_.op_.Clear();
2534 }
mutable_op(int index)2535 inline ::tensorflow::OpDef* OpList::mutable_op(int index) {
2536 // @@protoc_insertion_point(field_mutable:tensorflow.OpList.op)
2537 return _impl_.op_.Mutable(index);
2538 }
2539 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >*
mutable_op()2540 OpList::mutable_op() {
2541 // @@protoc_insertion_point(field_mutable_list:tensorflow.OpList.op)
2542 return &_impl_.op_;
2543 }
_internal_op(int index)2544 inline const ::tensorflow::OpDef& OpList::_internal_op(int index) const {
2545 return _impl_.op_.Get(index);
2546 }
op(int index)2547 inline const ::tensorflow::OpDef& OpList::op(int index) const {
2548 // @@protoc_insertion_point(field_get:tensorflow.OpList.op)
2549 return _internal_op(index);
2550 }
_internal_add_op()2551 inline ::tensorflow::OpDef* OpList::_internal_add_op() {
2552 return _impl_.op_.Add();
2553 }
add_op()2554 inline ::tensorflow::OpDef* OpList::add_op() {
2555 ::tensorflow::OpDef* _add = _internal_add_op();
2556 // @@protoc_insertion_point(field_add:tensorflow.OpList.op)
2557 return _add;
2558 }
2559 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::OpDef >&
op()2560 OpList::op() const {
2561 // @@protoc_insertion_point(field_list:tensorflow.OpList.op)
2562 return _impl_.op_;
2563 }
2564
2565 #ifdef __GNUC__
2566 #pragma GCC diagnostic pop
2567 #endif // __GNUC__
2568 // -------------------------------------------------------------------
2569
2570 // -------------------------------------------------------------------
2571
2572 // -------------------------------------------------------------------
2573
2574 // -------------------------------------------------------------------
2575
2576
2577 // @@protoc_insertion_point(namespace_scope)
2578
2579 } // namespace tensorflow
2580
2581 // @@protoc_insertion_point(global_scope)
2582
2583 #include <google/protobuf/port_undef.inc>
2584 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fframework_2fop_5fdef_2eproto
2585