1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/trackable_object_graph.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_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 <google/protobuf/wrappers.pb.h>
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 } // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace tensorflow {
47 class RegisteredSaver;
48 struct RegisteredSaverDefaultTypeInternal;
49 extern RegisteredSaverDefaultTypeInternal _RegisteredSaver_default_instance_;
50 class TrackableObjectGraph;
51 struct TrackableObjectGraphDefaultTypeInternal;
52 extern TrackableObjectGraphDefaultTypeInternal _TrackableObjectGraph_default_instance_;
53 class TrackableObjectGraph_TrackableObject;
54 struct TrackableObjectGraph_TrackableObjectDefaultTypeInternal;
55 extern TrackableObjectGraph_TrackableObjectDefaultTypeInternal _TrackableObjectGraph_TrackableObject_default_instance_;
56 class TrackableObjectGraph_TrackableObject_ObjectReference;
57 struct TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal;
58 extern TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal _TrackableObjectGraph_TrackableObject_ObjectReference_default_instance_;
59 class TrackableObjectGraph_TrackableObject_SerializedTensor;
60 struct TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal;
61 extern TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal _TrackableObjectGraph_TrackableObject_SerializedTensor_default_instance_;
62 class TrackableObjectGraph_TrackableObject_SlotVariableReference;
63 struct TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal;
64 extern TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal _TrackableObjectGraph_TrackableObject_SlotVariableReference_default_instance_;
65 } // namespace tensorflow
66 PROTOBUF_NAMESPACE_OPEN
67 template<> ::tensorflow::RegisteredSaver* Arena::CreateMaybeMessage<::tensorflow::RegisteredSaver>(Arena*);
68 template<> ::tensorflow::TrackableObjectGraph* Arena::CreateMaybeMessage<::tensorflow::TrackableObjectGraph>(Arena*);
69 template<> ::tensorflow::TrackableObjectGraph_TrackableObject* Arena::CreateMaybeMessage<::tensorflow::TrackableObjectGraph_TrackableObject>(Arena*);
70 template<> ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* Arena::CreateMaybeMessage<::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference>(Arena*);
71 template<> ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* Arena::CreateMaybeMessage<::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor>(Arena*);
72 template<> ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* Arena::CreateMaybeMessage<::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference>(Arena*);
73 PROTOBUF_NAMESPACE_CLOSE
74 namespace tensorflow {
75
76 // ===================================================================
77
78 class TrackableObjectGraph_TrackableObject_ObjectReference final :
79 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference) */ {
80 public:
TrackableObjectGraph_TrackableObject_ObjectReference()81 inline TrackableObjectGraph_TrackableObject_ObjectReference() : TrackableObjectGraph_TrackableObject_ObjectReference(nullptr) {}
82 ~TrackableObjectGraph_TrackableObject_ObjectReference() override;
83 explicit PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_ObjectReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
84
85 TrackableObjectGraph_TrackableObject_ObjectReference(const TrackableObjectGraph_TrackableObject_ObjectReference& from);
TrackableObjectGraph_TrackableObject_ObjectReference(TrackableObjectGraph_TrackableObject_ObjectReference && from)86 TrackableObjectGraph_TrackableObject_ObjectReference(TrackableObjectGraph_TrackableObject_ObjectReference&& from) noexcept
87 : TrackableObjectGraph_TrackableObject_ObjectReference() {
88 *this = ::std::move(from);
89 }
90
91 inline TrackableObjectGraph_TrackableObject_ObjectReference& operator=(const TrackableObjectGraph_TrackableObject_ObjectReference& from) {
92 if (this == &from) return *this;
93 CopyFrom(from);
94 return *this;
95 }
96 inline TrackableObjectGraph_TrackableObject_ObjectReference& operator=(TrackableObjectGraph_TrackableObject_ObjectReference&& from) noexcept {
97 if (this == &from) return *this;
98 if (GetOwningArena() == from.GetOwningArena()
99 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
100 && GetOwningArena() != nullptr
101 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
102 ) {
103 InternalSwap(&from);
104 } else {
105 CopyFrom(from);
106 }
107 return *this;
108 }
109
default_instance()110 static const TrackableObjectGraph_TrackableObject_ObjectReference& default_instance() {
111 return *internal_default_instance();
112 }
internal_default_instance()113 static inline const TrackableObjectGraph_TrackableObject_ObjectReference* internal_default_instance() {
114 return reinterpret_cast<const TrackableObjectGraph_TrackableObject_ObjectReference*>(
115 &_TrackableObjectGraph_TrackableObject_ObjectReference_default_instance_);
116 }
117 static constexpr int kIndexInFileMessages =
118 0;
119
swap(TrackableObjectGraph_TrackableObject_ObjectReference & a,TrackableObjectGraph_TrackableObject_ObjectReference & b)120 friend void swap(TrackableObjectGraph_TrackableObject_ObjectReference& a, TrackableObjectGraph_TrackableObject_ObjectReference& b) {
121 a.Swap(&b);
122 }
Swap(TrackableObjectGraph_TrackableObject_ObjectReference * other)123 inline void Swap(TrackableObjectGraph_TrackableObject_ObjectReference* other) {
124 if (other == this) return;
125 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
126 if (GetOwningArena() != nullptr &&
127 GetOwningArena() == other->GetOwningArena()) {
128 #else // PROTOBUF_FORCE_COPY_IN_SWAP
129 if (GetOwningArena() == other->GetOwningArena()) {
130 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
131 InternalSwap(other);
132 } else {
133 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
134 }
135 }
136 void UnsafeArenaSwap(TrackableObjectGraph_TrackableObject_ObjectReference* other) {
137 if (other == this) return;
138 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
139 InternalSwap(other);
140 }
141
142 // implements Message ----------------------------------------------
143
144 TrackableObjectGraph_TrackableObject_ObjectReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
145 return CreateMaybeMessage<TrackableObjectGraph_TrackableObject_ObjectReference>(arena);
146 }
147 TrackableObjectGraph_TrackableObject_ObjectReference* New() const {
148 return New(nullptr);
149 }
150 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
151 void CopyFrom(const TrackableObjectGraph_TrackableObject_ObjectReference& from);
152 void MergeFrom(const TrackableObjectGraph_TrackableObject_ObjectReference& from);
153 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
154 bool IsInitialized() const final;
155
156 size_t ByteSizeLong() const final;
157 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
158 ::uint8_t* _InternalSerialize(
159 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
160 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
161
162 private:
163 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
164 void SharedDtor();
165 void SetCachedSize(int size) const;
166 void InternalSwap(TrackableObjectGraph_TrackableObject_ObjectReference* other);
167
168 private:
169 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
170 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
171 return "tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference";
172 }
173 protected:
174 explicit TrackableObjectGraph_TrackableObject_ObjectReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
175 bool is_message_owned = false);
176 public:
177
178 std::string GetTypeName() const final;
179
180 // nested types ----------------------------------------------------
181
182 // accessors -------------------------------------------------------
183
184 enum : int {
185 kLocalNameFieldNumber = 2,
186 kNodeIdFieldNumber = 1,
187 };
188 // string local_name = 2;
189 void clear_local_name();
190 const std::string& local_name() const;
191 template <typename ArgT0 = const std::string&, typename... ArgT>
192 void set_local_name(ArgT0&& arg0, ArgT... args);
193 std::string* mutable_local_name();
194 PROTOBUF_NODISCARD std::string* release_local_name();
195 void set_allocated_local_name(std::string* local_name);
196 private:
197 const std::string& _internal_local_name() const;
198 inline PROTOBUF_ALWAYS_INLINE void _internal_set_local_name(const std::string& value);
199 std::string* _internal_mutable_local_name();
200 public:
201
202 // int32 node_id = 1;
203 void clear_node_id();
204 ::int32_t node_id() const;
205 void set_node_id(::int32_t value);
206 private:
207 ::int32_t _internal_node_id() const;
208 void _internal_set_node_id(::int32_t value);
209 public:
210
211 // @@protoc_insertion_point(class_scope:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
212 private:
213 class _Internal;
214
215 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
216 typedef void InternalArenaConstructable_;
217 typedef void DestructorSkippable_;
218 struct Impl_ {
219 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_name_;
220 ::int32_t node_id_;
221 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
222 };
223 union { Impl_ _impl_; };
224 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
225 };
226 // -------------------------------------------------------------------
227
228 class TrackableObjectGraph_TrackableObject_SerializedTensor final :
229 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor) */ {
230 public:
TrackableObjectGraph_TrackableObject_SerializedTensor()231 inline TrackableObjectGraph_TrackableObject_SerializedTensor() : TrackableObjectGraph_TrackableObject_SerializedTensor(nullptr) {}
232 ~TrackableObjectGraph_TrackableObject_SerializedTensor() override;
233 explicit PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SerializedTensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
234
235 TrackableObjectGraph_TrackableObject_SerializedTensor(const TrackableObjectGraph_TrackableObject_SerializedTensor& from);
TrackableObjectGraph_TrackableObject_SerializedTensor(TrackableObjectGraph_TrackableObject_SerializedTensor && from)236 TrackableObjectGraph_TrackableObject_SerializedTensor(TrackableObjectGraph_TrackableObject_SerializedTensor&& from) noexcept
237 : TrackableObjectGraph_TrackableObject_SerializedTensor() {
238 *this = ::std::move(from);
239 }
240
241 inline TrackableObjectGraph_TrackableObject_SerializedTensor& operator=(const TrackableObjectGraph_TrackableObject_SerializedTensor& from) {
242 if (this == &from) return *this;
243 CopyFrom(from);
244 return *this;
245 }
246 inline TrackableObjectGraph_TrackableObject_SerializedTensor& operator=(TrackableObjectGraph_TrackableObject_SerializedTensor&& from) noexcept {
247 if (this == &from) return *this;
248 if (GetOwningArena() == from.GetOwningArena()
249 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
250 && GetOwningArena() != nullptr
251 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
252 ) {
253 InternalSwap(&from);
254 } else {
255 CopyFrom(from);
256 }
257 return *this;
258 }
259
default_instance()260 static const TrackableObjectGraph_TrackableObject_SerializedTensor& default_instance() {
261 return *internal_default_instance();
262 }
internal_default_instance()263 static inline const TrackableObjectGraph_TrackableObject_SerializedTensor* internal_default_instance() {
264 return reinterpret_cast<const TrackableObjectGraph_TrackableObject_SerializedTensor*>(
265 &_TrackableObjectGraph_TrackableObject_SerializedTensor_default_instance_);
266 }
267 static constexpr int kIndexInFileMessages =
268 1;
269
swap(TrackableObjectGraph_TrackableObject_SerializedTensor & a,TrackableObjectGraph_TrackableObject_SerializedTensor & b)270 friend void swap(TrackableObjectGraph_TrackableObject_SerializedTensor& a, TrackableObjectGraph_TrackableObject_SerializedTensor& b) {
271 a.Swap(&b);
272 }
Swap(TrackableObjectGraph_TrackableObject_SerializedTensor * other)273 inline void Swap(TrackableObjectGraph_TrackableObject_SerializedTensor* other) {
274 if (other == this) return;
275 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
276 if (GetOwningArena() != nullptr &&
277 GetOwningArena() == other->GetOwningArena()) {
278 #else // PROTOBUF_FORCE_COPY_IN_SWAP
279 if (GetOwningArena() == other->GetOwningArena()) {
280 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
281 InternalSwap(other);
282 } else {
283 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
284 }
285 }
286 void UnsafeArenaSwap(TrackableObjectGraph_TrackableObject_SerializedTensor* other) {
287 if (other == this) return;
288 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
289 InternalSwap(other);
290 }
291
292 // implements Message ----------------------------------------------
293
294 TrackableObjectGraph_TrackableObject_SerializedTensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
295 return CreateMaybeMessage<TrackableObjectGraph_TrackableObject_SerializedTensor>(arena);
296 }
297 TrackableObjectGraph_TrackableObject_SerializedTensor* New() const {
298 return New(nullptr);
299 }
300 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
301 void CopyFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor& from);
302 void MergeFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor& from);
303 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
304 bool IsInitialized() const final;
305
306 size_t ByteSizeLong() const final;
307 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
308 ::uint8_t* _InternalSerialize(
309 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
310 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
311
312 private:
313 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
314 void SharedDtor();
315 void SetCachedSize(int size) const;
316 void InternalSwap(TrackableObjectGraph_TrackableObject_SerializedTensor* other);
317
318 private:
319 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
320 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
321 return "tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor";
322 }
323 protected:
324 explicit TrackableObjectGraph_TrackableObject_SerializedTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
325 bool is_message_owned = false);
326 public:
327
328 std::string GetTypeName() const final;
329
330 // nested types ----------------------------------------------------
331
332 // accessors -------------------------------------------------------
333
334 enum : int {
335 kNameFieldNumber = 1,
336 kFullNameFieldNumber = 2,
337 kCheckpointKeyFieldNumber = 3,
338 };
339 // string name = 1;
340 void clear_name();
341 const std::string& name() const;
342 template <typename ArgT0 = const std::string&, typename... ArgT>
343 void set_name(ArgT0&& arg0, ArgT... args);
344 std::string* mutable_name();
345 PROTOBUF_NODISCARD std::string* release_name();
346 void set_allocated_name(std::string* name);
347 private:
348 const std::string& _internal_name() const;
349 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
350 std::string* _internal_mutable_name();
351 public:
352
353 // string full_name = 2;
354 void clear_full_name();
355 const std::string& full_name() const;
356 template <typename ArgT0 = const std::string&, typename... ArgT>
357 void set_full_name(ArgT0&& arg0, ArgT... args);
358 std::string* mutable_full_name();
359 PROTOBUF_NODISCARD std::string* release_full_name();
360 void set_allocated_full_name(std::string* full_name);
361 private:
362 const std::string& _internal_full_name() const;
363 inline PROTOBUF_ALWAYS_INLINE void _internal_set_full_name(const std::string& value);
364 std::string* _internal_mutable_full_name();
365 public:
366
367 // string checkpoint_key = 3;
368 void clear_checkpoint_key();
369 const std::string& checkpoint_key() const;
370 template <typename ArgT0 = const std::string&, typename... ArgT>
371 void set_checkpoint_key(ArgT0&& arg0, ArgT... args);
372 std::string* mutable_checkpoint_key();
373 PROTOBUF_NODISCARD std::string* release_checkpoint_key();
374 void set_allocated_checkpoint_key(std::string* checkpoint_key);
375 private:
376 const std::string& _internal_checkpoint_key() const;
377 inline PROTOBUF_ALWAYS_INLINE void _internal_set_checkpoint_key(const std::string& value);
378 std::string* _internal_mutable_checkpoint_key();
379 public:
380
381 // @@protoc_insertion_point(class_scope:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
382 private:
383 class _Internal;
384
385 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
386 typedef void InternalArenaConstructable_;
387 typedef void DestructorSkippable_;
388 struct Impl_ {
389 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
390 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr full_name_;
391 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr checkpoint_key_;
392 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
393 };
394 union { Impl_ _impl_; };
395 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
396 };
397 // -------------------------------------------------------------------
398
399 class TrackableObjectGraph_TrackableObject_SlotVariableReference final :
400 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference) */ {
401 public:
TrackableObjectGraph_TrackableObject_SlotVariableReference()402 inline TrackableObjectGraph_TrackableObject_SlotVariableReference() : TrackableObjectGraph_TrackableObject_SlotVariableReference(nullptr) {}
403 ~TrackableObjectGraph_TrackableObject_SlotVariableReference() override;
404 explicit PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SlotVariableReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
405
406 TrackableObjectGraph_TrackableObject_SlotVariableReference(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from);
TrackableObjectGraph_TrackableObject_SlotVariableReference(TrackableObjectGraph_TrackableObject_SlotVariableReference && from)407 TrackableObjectGraph_TrackableObject_SlotVariableReference(TrackableObjectGraph_TrackableObject_SlotVariableReference&& from) noexcept
408 : TrackableObjectGraph_TrackableObject_SlotVariableReference() {
409 *this = ::std::move(from);
410 }
411
412 inline TrackableObjectGraph_TrackableObject_SlotVariableReference& operator=(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from) {
413 if (this == &from) return *this;
414 CopyFrom(from);
415 return *this;
416 }
417 inline TrackableObjectGraph_TrackableObject_SlotVariableReference& operator=(TrackableObjectGraph_TrackableObject_SlotVariableReference&& from) noexcept {
418 if (this == &from) return *this;
419 if (GetOwningArena() == from.GetOwningArena()
420 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
421 && GetOwningArena() != nullptr
422 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
423 ) {
424 InternalSwap(&from);
425 } else {
426 CopyFrom(from);
427 }
428 return *this;
429 }
430
default_instance()431 static const TrackableObjectGraph_TrackableObject_SlotVariableReference& default_instance() {
432 return *internal_default_instance();
433 }
internal_default_instance()434 static inline const TrackableObjectGraph_TrackableObject_SlotVariableReference* internal_default_instance() {
435 return reinterpret_cast<const TrackableObjectGraph_TrackableObject_SlotVariableReference*>(
436 &_TrackableObjectGraph_TrackableObject_SlotVariableReference_default_instance_);
437 }
438 static constexpr int kIndexInFileMessages =
439 2;
440
swap(TrackableObjectGraph_TrackableObject_SlotVariableReference & a,TrackableObjectGraph_TrackableObject_SlotVariableReference & b)441 friend void swap(TrackableObjectGraph_TrackableObject_SlotVariableReference& a, TrackableObjectGraph_TrackableObject_SlotVariableReference& b) {
442 a.Swap(&b);
443 }
Swap(TrackableObjectGraph_TrackableObject_SlotVariableReference * other)444 inline void Swap(TrackableObjectGraph_TrackableObject_SlotVariableReference* other) {
445 if (other == this) return;
446 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
447 if (GetOwningArena() != nullptr &&
448 GetOwningArena() == other->GetOwningArena()) {
449 #else // PROTOBUF_FORCE_COPY_IN_SWAP
450 if (GetOwningArena() == other->GetOwningArena()) {
451 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
452 InternalSwap(other);
453 } else {
454 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
455 }
456 }
457 void UnsafeArenaSwap(TrackableObjectGraph_TrackableObject_SlotVariableReference* other) {
458 if (other == this) return;
459 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
460 InternalSwap(other);
461 }
462
463 // implements Message ----------------------------------------------
464
465 TrackableObjectGraph_TrackableObject_SlotVariableReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
466 return CreateMaybeMessage<TrackableObjectGraph_TrackableObject_SlotVariableReference>(arena);
467 }
468 TrackableObjectGraph_TrackableObject_SlotVariableReference* New() const {
469 return New(nullptr);
470 }
471 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
472 void CopyFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from);
473 void MergeFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from);
474 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
475 bool IsInitialized() const final;
476
477 size_t ByteSizeLong() const final;
478 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
479 ::uint8_t* _InternalSerialize(
480 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
481 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
482
483 private:
484 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
485 void SharedDtor();
486 void SetCachedSize(int size) const;
487 void InternalSwap(TrackableObjectGraph_TrackableObject_SlotVariableReference* other);
488
489 private:
490 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
491 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
492 return "tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference";
493 }
494 protected:
495 explicit TrackableObjectGraph_TrackableObject_SlotVariableReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
496 bool is_message_owned = false);
497 public:
498
499 std::string GetTypeName() const final;
500
501 // nested types ----------------------------------------------------
502
503 // accessors -------------------------------------------------------
504
505 enum : int {
506 kSlotNameFieldNumber = 2,
507 kOriginalVariableNodeIdFieldNumber = 1,
508 kSlotVariableNodeIdFieldNumber = 3,
509 };
510 // string slot_name = 2;
511 void clear_slot_name();
512 const std::string& slot_name() const;
513 template <typename ArgT0 = const std::string&, typename... ArgT>
514 void set_slot_name(ArgT0&& arg0, ArgT... args);
515 std::string* mutable_slot_name();
516 PROTOBUF_NODISCARD std::string* release_slot_name();
517 void set_allocated_slot_name(std::string* slot_name);
518 private:
519 const std::string& _internal_slot_name() const;
520 inline PROTOBUF_ALWAYS_INLINE void _internal_set_slot_name(const std::string& value);
521 std::string* _internal_mutable_slot_name();
522 public:
523
524 // int32 original_variable_node_id = 1;
525 void clear_original_variable_node_id();
526 ::int32_t original_variable_node_id() const;
527 void set_original_variable_node_id(::int32_t value);
528 private:
529 ::int32_t _internal_original_variable_node_id() const;
530 void _internal_set_original_variable_node_id(::int32_t value);
531 public:
532
533 // int32 slot_variable_node_id = 3;
534 void clear_slot_variable_node_id();
535 ::int32_t slot_variable_node_id() const;
536 void set_slot_variable_node_id(::int32_t value);
537 private:
538 ::int32_t _internal_slot_variable_node_id() const;
539 void _internal_set_slot_variable_node_id(::int32_t value);
540 public:
541
542 // @@protoc_insertion_point(class_scope:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
543 private:
544 class _Internal;
545
546 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
547 typedef void InternalArenaConstructable_;
548 typedef void DestructorSkippable_;
549 struct Impl_ {
550 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr slot_name_;
551 ::int32_t original_variable_node_id_;
552 ::int32_t slot_variable_node_id_;
553 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
554 };
555 union { Impl_ _impl_; };
556 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
557 };
558 // -------------------------------------------------------------------
559
560 class TrackableObjectGraph_TrackableObject final :
561 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TrackableObjectGraph.TrackableObject) */ {
562 public:
TrackableObjectGraph_TrackableObject()563 inline TrackableObjectGraph_TrackableObject() : TrackableObjectGraph_TrackableObject(nullptr) {}
564 ~TrackableObjectGraph_TrackableObject() override;
565 explicit PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
566
567 TrackableObjectGraph_TrackableObject(const TrackableObjectGraph_TrackableObject& from);
TrackableObjectGraph_TrackableObject(TrackableObjectGraph_TrackableObject && from)568 TrackableObjectGraph_TrackableObject(TrackableObjectGraph_TrackableObject&& from) noexcept
569 : TrackableObjectGraph_TrackableObject() {
570 *this = ::std::move(from);
571 }
572
573 inline TrackableObjectGraph_TrackableObject& operator=(const TrackableObjectGraph_TrackableObject& from) {
574 if (this == &from) return *this;
575 CopyFrom(from);
576 return *this;
577 }
578 inline TrackableObjectGraph_TrackableObject& operator=(TrackableObjectGraph_TrackableObject&& from) noexcept {
579 if (this == &from) return *this;
580 if (GetOwningArena() == from.GetOwningArena()
581 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
582 && GetOwningArena() != nullptr
583 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
584 ) {
585 InternalSwap(&from);
586 } else {
587 CopyFrom(from);
588 }
589 return *this;
590 }
591
default_instance()592 static const TrackableObjectGraph_TrackableObject& default_instance() {
593 return *internal_default_instance();
594 }
internal_default_instance()595 static inline const TrackableObjectGraph_TrackableObject* internal_default_instance() {
596 return reinterpret_cast<const TrackableObjectGraph_TrackableObject*>(
597 &_TrackableObjectGraph_TrackableObject_default_instance_);
598 }
599 static constexpr int kIndexInFileMessages =
600 3;
601
swap(TrackableObjectGraph_TrackableObject & a,TrackableObjectGraph_TrackableObject & b)602 friend void swap(TrackableObjectGraph_TrackableObject& a, TrackableObjectGraph_TrackableObject& b) {
603 a.Swap(&b);
604 }
Swap(TrackableObjectGraph_TrackableObject * other)605 inline void Swap(TrackableObjectGraph_TrackableObject* other) {
606 if (other == this) return;
607 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
608 if (GetOwningArena() != nullptr &&
609 GetOwningArena() == other->GetOwningArena()) {
610 #else // PROTOBUF_FORCE_COPY_IN_SWAP
611 if (GetOwningArena() == other->GetOwningArena()) {
612 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
613 InternalSwap(other);
614 } else {
615 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
616 }
617 }
618 void UnsafeArenaSwap(TrackableObjectGraph_TrackableObject* other) {
619 if (other == this) return;
620 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
621 InternalSwap(other);
622 }
623
624 // implements Message ----------------------------------------------
625
626 TrackableObjectGraph_TrackableObject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
627 return CreateMaybeMessage<TrackableObjectGraph_TrackableObject>(arena);
628 }
629 TrackableObjectGraph_TrackableObject* New() const {
630 return New(nullptr);
631 }
632 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
633 void CopyFrom(const TrackableObjectGraph_TrackableObject& from);
634 void MergeFrom(const TrackableObjectGraph_TrackableObject& from);
635 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
636 bool IsInitialized() const final;
637
638 size_t ByteSizeLong() const final;
639 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
640 ::uint8_t* _InternalSerialize(
641 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
642 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
643
644 private:
645 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
646 void SharedDtor();
647 void SetCachedSize(int size) const;
648 void InternalSwap(TrackableObjectGraph_TrackableObject* other);
649
650 private:
651 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
652 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
653 return "tensorflow.TrackableObjectGraph.TrackableObject";
654 }
655 protected:
656 explicit TrackableObjectGraph_TrackableObject(::PROTOBUF_NAMESPACE_ID::Arena* arena,
657 bool is_message_owned = false);
658 public:
659
660 std::string GetTypeName() const final;
661
662 // nested types ----------------------------------------------------
663
664 typedef TrackableObjectGraph_TrackableObject_ObjectReference ObjectReference;
665 typedef TrackableObjectGraph_TrackableObject_SerializedTensor SerializedTensor;
666 typedef TrackableObjectGraph_TrackableObject_SlotVariableReference SlotVariableReference;
667
668 // accessors -------------------------------------------------------
669
670 enum : int {
671 kChildrenFieldNumber = 1,
672 kAttributesFieldNumber = 2,
673 kSlotVariablesFieldNumber = 3,
674 kRegisteredSaverFieldNumber = 4,
675 kHasCheckpointValuesFieldNumber = 5,
676 };
677 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
678 int children_size() const;
679 private:
680 int _internal_children_size() const;
681 public:
682 void clear_children();
683 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* mutable_children(int index);
684 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
685 mutable_children();
686 private:
687 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& _internal_children(int index) const;
688 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _internal_add_children();
689 public:
690 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& children(int index) const;
691 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* add_children();
692 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
693 children() const;
694
695 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor attributes = 2;
696 int attributes_size() const;
697 private:
698 int _internal_attributes_size() const;
699 public:
700 void clear_attributes();
701 ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* mutable_attributes(int index);
702 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >*
703 mutable_attributes();
704 private:
705 const ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor& _internal_attributes(int index) const;
706 ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* _internal_add_attributes();
707 public:
708 const ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor& attributes(int index) const;
709 ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* add_attributes();
710 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >&
711 attributes() const;
712
713 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
714 int slot_variables_size() const;
715 private:
716 int _internal_slot_variables_size() const;
717 public:
718 void clear_slot_variables();
719 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* mutable_slot_variables(int index);
720 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >*
721 mutable_slot_variables();
722 private:
723 const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& _internal_slot_variables(int index) const;
724 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* _internal_add_slot_variables();
725 public:
726 const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& slot_variables(int index) const;
727 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* add_slot_variables();
728 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >&
729 slot_variables() const;
730
731 // .tensorflow.RegisteredSaver registered_saver = 4;
732 bool has_registered_saver() const;
733 private:
734 bool _internal_has_registered_saver() const;
735 public:
736 void clear_registered_saver();
737 const ::tensorflow::RegisteredSaver& registered_saver() const;
738 PROTOBUF_NODISCARD ::tensorflow::RegisteredSaver* release_registered_saver();
739 ::tensorflow::RegisteredSaver* mutable_registered_saver();
740 void set_allocated_registered_saver(::tensorflow::RegisteredSaver* registered_saver);
741 private:
742 const ::tensorflow::RegisteredSaver& _internal_registered_saver() const;
743 ::tensorflow::RegisteredSaver* _internal_mutable_registered_saver();
744 public:
745 void unsafe_arena_set_allocated_registered_saver(
746 ::tensorflow::RegisteredSaver* registered_saver);
747 ::tensorflow::RegisteredSaver* unsafe_arena_release_registered_saver();
748
749 // .google.protobuf.BoolValue has_checkpoint_values = 5;
750 bool has_has_checkpoint_values() const;
751 private:
752 bool _internal_has_has_checkpoint_values() const;
753 public:
754 void clear_has_checkpoint_values();
755 const ::PROTOBUF_NAMESPACE_ID::BoolValue& has_checkpoint_values() const;
756 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::BoolValue* release_has_checkpoint_values();
757 ::PROTOBUF_NAMESPACE_ID::BoolValue* mutable_has_checkpoint_values();
758 void set_allocated_has_checkpoint_values(::PROTOBUF_NAMESPACE_ID::BoolValue* has_checkpoint_values);
759 private:
760 const ::PROTOBUF_NAMESPACE_ID::BoolValue& _internal_has_checkpoint_values() const;
761 ::PROTOBUF_NAMESPACE_ID::BoolValue* _internal_mutable_has_checkpoint_values();
762 public:
763 void unsafe_arena_set_allocated_has_checkpoint_values(
764 ::PROTOBUF_NAMESPACE_ID::BoolValue* has_checkpoint_values);
765 ::PROTOBUF_NAMESPACE_ID::BoolValue* unsafe_arena_release_has_checkpoint_values();
766
767 // @@protoc_insertion_point(class_scope:tensorflow.TrackableObjectGraph.TrackableObject)
768 private:
769 class _Internal;
770
771 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
772 typedef void InternalArenaConstructable_;
773 typedef void DestructorSkippable_;
774 struct Impl_ {
775 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference > children_;
776 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor > attributes_;
777 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference > slot_variables_;
778 ::tensorflow::RegisteredSaver* registered_saver_;
779 ::PROTOBUF_NAMESPACE_ID::BoolValue* has_checkpoint_values_;
780 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
781 };
782 union { Impl_ _impl_; };
783 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
784 };
785 // -------------------------------------------------------------------
786
787 class TrackableObjectGraph final :
788 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TrackableObjectGraph) */ {
789 public:
TrackableObjectGraph()790 inline TrackableObjectGraph() : TrackableObjectGraph(nullptr) {}
791 ~TrackableObjectGraph() override;
792 explicit PROTOBUF_CONSTEXPR TrackableObjectGraph(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
793
794 TrackableObjectGraph(const TrackableObjectGraph& from);
TrackableObjectGraph(TrackableObjectGraph && from)795 TrackableObjectGraph(TrackableObjectGraph&& from) noexcept
796 : TrackableObjectGraph() {
797 *this = ::std::move(from);
798 }
799
800 inline TrackableObjectGraph& operator=(const TrackableObjectGraph& from) {
801 if (this == &from) return *this;
802 CopyFrom(from);
803 return *this;
804 }
805 inline TrackableObjectGraph& operator=(TrackableObjectGraph&& from) noexcept {
806 if (this == &from) return *this;
807 if (GetOwningArena() == from.GetOwningArena()
808 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
809 && GetOwningArena() != nullptr
810 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
811 ) {
812 InternalSwap(&from);
813 } else {
814 CopyFrom(from);
815 }
816 return *this;
817 }
818
default_instance()819 static const TrackableObjectGraph& default_instance() {
820 return *internal_default_instance();
821 }
internal_default_instance()822 static inline const TrackableObjectGraph* internal_default_instance() {
823 return reinterpret_cast<const TrackableObjectGraph*>(
824 &_TrackableObjectGraph_default_instance_);
825 }
826 static constexpr int kIndexInFileMessages =
827 4;
828
swap(TrackableObjectGraph & a,TrackableObjectGraph & b)829 friend void swap(TrackableObjectGraph& a, TrackableObjectGraph& b) {
830 a.Swap(&b);
831 }
Swap(TrackableObjectGraph * other)832 inline void Swap(TrackableObjectGraph* other) {
833 if (other == this) return;
834 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
835 if (GetOwningArena() != nullptr &&
836 GetOwningArena() == other->GetOwningArena()) {
837 #else // PROTOBUF_FORCE_COPY_IN_SWAP
838 if (GetOwningArena() == other->GetOwningArena()) {
839 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
840 InternalSwap(other);
841 } else {
842 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
843 }
844 }
845 void UnsafeArenaSwap(TrackableObjectGraph* other) {
846 if (other == this) return;
847 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
848 InternalSwap(other);
849 }
850
851 // implements Message ----------------------------------------------
852
853 TrackableObjectGraph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
854 return CreateMaybeMessage<TrackableObjectGraph>(arena);
855 }
856 TrackableObjectGraph* New() const {
857 return New(nullptr);
858 }
859 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
860 void CopyFrom(const TrackableObjectGraph& from);
861 void MergeFrom(const TrackableObjectGraph& from);
862 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
863 bool IsInitialized() const final;
864
865 size_t ByteSizeLong() const final;
866 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
867 ::uint8_t* _InternalSerialize(
868 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
869 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
870
871 private:
872 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
873 void SharedDtor();
874 void SetCachedSize(int size) const;
875 void InternalSwap(TrackableObjectGraph* other);
876
877 private:
878 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
879 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
880 return "tensorflow.TrackableObjectGraph";
881 }
882 protected:
883 explicit TrackableObjectGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
884 bool is_message_owned = false);
885 public:
886
887 std::string GetTypeName() const final;
888
889 // nested types ----------------------------------------------------
890
891 typedef TrackableObjectGraph_TrackableObject TrackableObject;
892
893 // accessors -------------------------------------------------------
894
895 enum : int {
896 kNodesFieldNumber = 1,
897 };
898 // repeated .tensorflow.TrackableObjectGraph.TrackableObject nodes = 1;
899 int nodes_size() const;
900 private:
901 int _internal_nodes_size() const;
902 public:
903 void clear_nodes();
904 ::tensorflow::TrackableObjectGraph_TrackableObject* mutable_nodes(int index);
905 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject >*
906 mutable_nodes();
907 private:
908 const ::tensorflow::TrackableObjectGraph_TrackableObject& _internal_nodes(int index) const;
909 ::tensorflow::TrackableObjectGraph_TrackableObject* _internal_add_nodes();
910 public:
911 const ::tensorflow::TrackableObjectGraph_TrackableObject& nodes(int index) const;
912 ::tensorflow::TrackableObjectGraph_TrackableObject* add_nodes();
913 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject >&
914 nodes() const;
915
916 // @@protoc_insertion_point(class_scope:tensorflow.TrackableObjectGraph)
917 private:
918 class _Internal;
919
920 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
921 typedef void InternalArenaConstructable_;
922 typedef void DestructorSkippable_;
923 struct Impl_ {
924 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject > nodes_;
925 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
926 };
927 union { Impl_ _impl_; };
928 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
929 };
930 // -------------------------------------------------------------------
931
932 class RegisteredSaver final :
933 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RegisteredSaver) */ {
934 public:
RegisteredSaver()935 inline RegisteredSaver() : RegisteredSaver(nullptr) {}
936 ~RegisteredSaver() override;
937 explicit PROTOBUF_CONSTEXPR RegisteredSaver(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
938
939 RegisteredSaver(const RegisteredSaver& from);
RegisteredSaver(RegisteredSaver && from)940 RegisteredSaver(RegisteredSaver&& from) noexcept
941 : RegisteredSaver() {
942 *this = ::std::move(from);
943 }
944
945 inline RegisteredSaver& operator=(const RegisteredSaver& from) {
946 if (this == &from) return *this;
947 CopyFrom(from);
948 return *this;
949 }
950 inline RegisteredSaver& operator=(RegisteredSaver&& from) noexcept {
951 if (this == &from) return *this;
952 if (GetOwningArena() == from.GetOwningArena()
953 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
954 && GetOwningArena() != nullptr
955 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
956 ) {
957 InternalSwap(&from);
958 } else {
959 CopyFrom(from);
960 }
961 return *this;
962 }
963
default_instance()964 static const RegisteredSaver& default_instance() {
965 return *internal_default_instance();
966 }
internal_default_instance()967 static inline const RegisteredSaver* internal_default_instance() {
968 return reinterpret_cast<const RegisteredSaver*>(
969 &_RegisteredSaver_default_instance_);
970 }
971 static constexpr int kIndexInFileMessages =
972 5;
973
swap(RegisteredSaver & a,RegisteredSaver & b)974 friend void swap(RegisteredSaver& a, RegisteredSaver& b) {
975 a.Swap(&b);
976 }
Swap(RegisteredSaver * other)977 inline void Swap(RegisteredSaver* other) {
978 if (other == this) return;
979 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
980 if (GetOwningArena() != nullptr &&
981 GetOwningArena() == other->GetOwningArena()) {
982 #else // PROTOBUF_FORCE_COPY_IN_SWAP
983 if (GetOwningArena() == other->GetOwningArena()) {
984 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
985 InternalSwap(other);
986 } else {
987 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
988 }
989 }
990 void UnsafeArenaSwap(RegisteredSaver* other) {
991 if (other == this) return;
992 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
993 InternalSwap(other);
994 }
995
996 // implements Message ----------------------------------------------
997
998 RegisteredSaver* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
999 return CreateMaybeMessage<RegisteredSaver>(arena);
1000 }
1001 RegisteredSaver* New() const {
1002 return New(nullptr);
1003 }
1004 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1005 void CopyFrom(const RegisteredSaver& from);
1006 void MergeFrom(const RegisteredSaver& from);
1007 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1008 bool IsInitialized() const final;
1009
1010 size_t ByteSizeLong() const final;
1011 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1012 ::uint8_t* _InternalSerialize(
1013 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1014 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1015
1016 private:
1017 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1018 void SharedDtor();
1019 void SetCachedSize(int size) const;
1020 void InternalSwap(RegisteredSaver* other);
1021
1022 private:
1023 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1024 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1025 return "tensorflow.RegisteredSaver";
1026 }
1027 protected:
1028 explicit RegisteredSaver(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1029 bool is_message_owned = false);
1030 public:
1031
1032 std::string GetTypeName() const final;
1033
1034 // nested types ----------------------------------------------------
1035
1036 // accessors -------------------------------------------------------
1037
1038 enum : int {
1039 kNameFieldNumber = 1,
1040 kObjectNameFieldNumber = 2,
1041 };
1042 // string name = 1;
1043 void clear_name();
1044 const std::string& name() const;
1045 template <typename ArgT0 = const std::string&, typename... ArgT>
1046 void set_name(ArgT0&& arg0, ArgT... args);
1047 std::string* mutable_name();
1048 PROTOBUF_NODISCARD std::string* release_name();
1049 void set_allocated_name(std::string* name);
1050 private:
1051 const std::string& _internal_name() const;
1052 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1053 std::string* _internal_mutable_name();
1054 public:
1055
1056 // string object_name = 2;
1057 void clear_object_name();
1058 const std::string& object_name() const;
1059 template <typename ArgT0 = const std::string&, typename... ArgT>
1060 void set_object_name(ArgT0&& arg0, ArgT... args);
1061 std::string* mutable_object_name();
1062 PROTOBUF_NODISCARD std::string* release_object_name();
1063 void set_allocated_object_name(std::string* object_name);
1064 private:
1065 const std::string& _internal_object_name() const;
1066 inline PROTOBUF_ALWAYS_INLINE void _internal_set_object_name(const std::string& value);
1067 std::string* _internal_mutable_object_name();
1068 public:
1069
1070 // @@protoc_insertion_point(class_scope:tensorflow.RegisteredSaver)
1071 private:
1072 class _Internal;
1073
1074 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1075 typedef void InternalArenaConstructable_;
1076 typedef void DestructorSkippable_;
1077 struct Impl_ {
1078 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1079 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr object_name_;
1080 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1081 };
1082 union { Impl_ _impl_; };
1083 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto;
1084 };
1085 // ===================================================================
1086
1087
1088 // ===================================================================
1089
1090 #ifdef __GNUC__
1091 #pragma GCC diagnostic push
1092 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1093 #endif // __GNUC__
1094 // TrackableObjectGraph_TrackableObject_ObjectReference
1095
1096 // int32 node_id = 1;
clear_node_id()1097 inline void TrackableObjectGraph_TrackableObject_ObjectReference::clear_node_id() {
1098 _impl_.node_id_ = 0;
1099 }
_internal_node_id()1100 inline ::int32_t TrackableObjectGraph_TrackableObject_ObjectReference::_internal_node_id() const {
1101 return _impl_.node_id_;
1102 }
node_id()1103 inline ::int32_t TrackableObjectGraph_TrackableObject_ObjectReference::node_id() const {
1104 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.node_id)
1105 return _internal_node_id();
1106 }
_internal_set_node_id(::int32_t value)1107 inline void TrackableObjectGraph_TrackableObject_ObjectReference::_internal_set_node_id(::int32_t value) {
1108
1109 _impl_.node_id_ = value;
1110 }
set_node_id(::int32_t value)1111 inline void TrackableObjectGraph_TrackableObject_ObjectReference::set_node_id(::int32_t value) {
1112 _internal_set_node_id(value);
1113 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.node_id)
1114 }
1115
1116 // string local_name = 2;
clear_local_name()1117 inline void TrackableObjectGraph_TrackableObject_ObjectReference::clear_local_name() {
1118 _impl_.local_name_.ClearToEmpty();
1119 }
local_name()1120 inline const std::string& TrackableObjectGraph_TrackableObject_ObjectReference::local_name() const {
1121 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name)
1122 return _internal_local_name();
1123 }
1124 template <typename ArgT0, typename... ArgT>
1125 inline PROTOBUF_ALWAYS_INLINE
set_local_name(ArgT0 && arg0,ArgT...args)1126 void TrackableObjectGraph_TrackableObject_ObjectReference::set_local_name(ArgT0&& arg0, ArgT... args) {
1127
1128 _impl_.local_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1129 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name)
1130 }
mutable_local_name()1131 inline std::string* TrackableObjectGraph_TrackableObject_ObjectReference::mutable_local_name() {
1132 std::string* _s = _internal_mutable_local_name();
1133 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name)
1134 return _s;
1135 }
_internal_local_name()1136 inline const std::string& TrackableObjectGraph_TrackableObject_ObjectReference::_internal_local_name() const {
1137 return _impl_.local_name_.Get();
1138 }
_internal_set_local_name(const std::string & value)1139 inline void TrackableObjectGraph_TrackableObject_ObjectReference::_internal_set_local_name(const std::string& value) {
1140
1141 _impl_.local_name_.Set(value, GetArenaForAllocation());
1142 }
_internal_mutable_local_name()1143 inline std::string* TrackableObjectGraph_TrackableObject_ObjectReference::_internal_mutable_local_name() {
1144
1145 return _impl_.local_name_.Mutable(GetArenaForAllocation());
1146 }
release_local_name()1147 inline std::string* TrackableObjectGraph_TrackableObject_ObjectReference::release_local_name() {
1148 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name)
1149 return _impl_.local_name_.Release();
1150 }
set_allocated_local_name(std::string * local_name)1151 inline void TrackableObjectGraph_TrackableObject_ObjectReference::set_allocated_local_name(std::string* local_name) {
1152 _impl_.local_name_.SetAllocated(local_name, GetArenaForAllocation());
1153 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1154 if (_impl_.local_name_.IsDefault()) {
1155 _impl_.local_name_.Set("", GetArenaForAllocation());
1156 }
1157 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1158 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name)
1159 }
1160
1161 // -------------------------------------------------------------------
1162
1163 // TrackableObjectGraph_TrackableObject_SerializedTensor
1164
1165 // string name = 1;
clear_name()1166 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::clear_name() {
1167 _impl_.name_.ClearToEmpty();
1168 }
name()1169 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::name() const {
1170 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name)
1171 return _internal_name();
1172 }
1173 template <typename ArgT0, typename... ArgT>
1174 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1175 void TrackableObjectGraph_TrackableObject_SerializedTensor::set_name(ArgT0&& arg0, ArgT... args) {
1176
1177 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1178 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name)
1179 }
mutable_name()1180 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::mutable_name() {
1181 std::string* _s = _internal_mutable_name();
1182 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name)
1183 return _s;
1184 }
_internal_name()1185 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_name() const {
1186 return _impl_.name_.Get();
1187 }
_internal_set_name(const std::string & value)1188 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_set_name(const std::string& value) {
1189
1190 _impl_.name_.Set(value, GetArenaForAllocation());
1191 }
_internal_mutable_name()1192 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_mutable_name() {
1193
1194 return _impl_.name_.Mutable(GetArenaForAllocation());
1195 }
release_name()1196 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::release_name() {
1197 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name)
1198 return _impl_.name_.Release();
1199 }
set_allocated_name(std::string * name)1200 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::set_allocated_name(std::string* name) {
1201 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1202 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1203 if (_impl_.name_.IsDefault()) {
1204 _impl_.name_.Set("", GetArenaForAllocation());
1205 }
1206 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1207 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name)
1208 }
1209
1210 // string full_name = 2;
clear_full_name()1211 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::clear_full_name() {
1212 _impl_.full_name_.ClearToEmpty();
1213 }
full_name()1214 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::full_name() const {
1215 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name)
1216 return _internal_full_name();
1217 }
1218 template <typename ArgT0, typename... ArgT>
1219 inline PROTOBUF_ALWAYS_INLINE
set_full_name(ArgT0 && arg0,ArgT...args)1220 void TrackableObjectGraph_TrackableObject_SerializedTensor::set_full_name(ArgT0&& arg0, ArgT... args) {
1221
1222 _impl_.full_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1223 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name)
1224 }
mutable_full_name()1225 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::mutable_full_name() {
1226 std::string* _s = _internal_mutable_full_name();
1227 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name)
1228 return _s;
1229 }
_internal_full_name()1230 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_full_name() const {
1231 return _impl_.full_name_.Get();
1232 }
_internal_set_full_name(const std::string & value)1233 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_set_full_name(const std::string& value) {
1234
1235 _impl_.full_name_.Set(value, GetArenaForAllocation());
1236 }
_internal_mutable_full_name()1237 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_mutable_full_name() {
1238
1239 return _impl_.full_name_.Mutable(GetArenaForAllocation());
1240 }
release_full_name()1241 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::release_full_name() {
1242 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name)
1243 return _impl_.full_name_.Release();
1244 }
set_allocated_full_name(std::string * full_name)1245 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::set_allocated_full_name(std::string* full_name) {
1246 _impl_.full_name_.SetAllocated(full_name, GetArenaForAllocation());
1247 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1248 if (_impl_.full_name_.IsDefault()) {
1249 _impl_.full_name_.Set("", GetArenaForAllocation());
1250 }
1251 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1252 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name)
1253 }
1254
1255 // string checkpoint_key = 3;
clear_checkpoint_key()1256 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::clear_checkpoint_key() {
1257 _impl_.checkpoint_key_.ClearToEmpty();
1258 }
checkpoint_key()1259 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::checkpoint_key() const {
1260 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key)
1261 return _internal_checkpoint_key();
1262 }
1263 template <typename ArgT0, typename... ArgT>
1264 inline PROTOBUF_ALWAYS_INLINE
set_checkpoint_key(ArgT0 && arg0,ArgT...args)1265 void TrackableObjectGraph_TrackableObject_SerializedTensor::set_checkpoint_key(ArgT0&& arg0, ArgT... args) {
1266
1267 _impl_.checkpoint_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1268 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key)
1269 }
mutable_checkpoint_key()1270 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::mutable_checkpoint_key() {
1271 std::string* _s = _internal_mutable_checkpoint_key();
1272 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key)
1273 return _s;
1274 }
_internal_checkpoint_key()1275 inline const std::string& TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_checkpoint_key() const {
1276 return _impl_.checkpoint_key_.Get();
1277 }
_internal_set_checkpoint_key(const std::string & value)1278 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_set_checkpoint_key(const std::string& value) {
1279
1280 _impl_.checkpoint_key_.Set(value, GetArenaForAllocation());
1281 }
_internal_mutable_checkpoint_key()1282 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::_internal_mutable_checkpoint_key() {
1283
1284 return _impl_.checkpoint_key_.Mutable(GetArenaForAllocation());
1285 }
release_checkpoint_key()1286 inline std::string* TrackableObjectGraph_TrackableObject_SerializedTensor::release_checkpoint_key() {
1287 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key)
1288 return _impl_.checkpoint_key_.Release();
1289 }
set_allocated_checkpoint_key(std::string * checkpoint_key)1290 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::set_allocated_checkpoint_key(std::string* checkpoint_key) {
1291 _impl_.checkpoint_key_.SetAllocated(checkpoint_key, GetArenaForAllocation());
1292 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1293 if (_impl_.checkpoint_key_.IsDefault()) {
1294 _impl_.checkpoint_key_.Set("", GetArenaForAllocation());
1295 }
1296 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1297 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key)
1298 }
1299
1300 // -------------------------------------------------------------------
1301
1302 // TrackableObjectGraph_TrackableObject_SlotVariableReference
1303
1304 // int32 original_variable_node_id = 1;
clear_original_variable_node_id()1305 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::clear_original_variable_node_id() {
1306 _impl_.original_variable_node_id_ = 0;
1307 }
_internal_original_variable_node_id()1308 inline ::int32_t TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_original_variable_node_id() const {
1309 return _impl_.original_variable_node_id_;
1310 }
original_variable_node_id()1311 inline ::int32_t TrackableObjectGraph_TrackableObject_SlotVariableReference::original_variable_node_id() const {
1312 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.original_variable_node_id)
1313 return _internal_original_variable_node_id();
1314 }
_internal_set_original_variable_node_id(::int32_t value)1315 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_set_original_variable_node_id(::int32_t value) {
1316
1317 _impl_.original_variable_node_id_ = value;
1318 }
set_original_variable_node_id(::int32_t value)1319 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::set_original_variable_node_id(::int32_t value) {
1320 _internal_set_original_variable_node_id(value);
1321 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.original_variable_node_id)
1322 }
1323
1324 // string slot_name = 2;
clear_slot_name()1325 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::clear_slot_name() {
1326 _impl_.slot_name_.ClearToEmpty();
1327 }
slot_name()1328 inline const std::string& TrackableObjectGraph_TrackableObject_SlotVariableReference::slot_name() const {
1329 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name)
1330 return _internal_slot_name();
1331 }
1332 template <typename ArgT0, typename... ArgT>
1333 inline PROTOBUF_ALWAYS_INLINE
set_slot_name(ArgT0 && arg0,ArgT...args)1334 void TrackableObjectGraph_TrackableObject_SlotVariableReference::set_slot_name(ArgT0&& arg0, ArgT... args) {
1335
1336 _impl_.slot_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1337 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name)
1338 }
mutable_slot_name()1339 inline std::string* TrackableObjectGraph_TrackableObject_SlotVariableReference::mutable_slot_name() {
1340 std::string* _s = _internal_mutable_slot_name();
1341 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name)
1342 return _s;
1343 }
_internal_slot_name()1344 inline const std::string& TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_slot_name() const {
1345 return _impl_.slot_name_.Get();
1346 }
_internal_set_slot_name(const std::string & value)1347 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_set_slot_name(const std::string& value) {
1348
1349 _impl_.slot_name_.Set(value, GetArenaForAllocation());
1350 }
_internal_mutable_slot_name()1351 inline std::string* TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_mutable_slot_name() {
1352
1353 return _impl_.slot_name_.Mutable(GetArenaForAllocation());
1354 }
release_slot_name()1355 inline std::string* TrackableObjectGraph_TrackableObject_SlotVariableReference::release_slot_name() {
1356 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name)
1357 return _impl_.slot_name_.Release();
1358 }
set_allocated_slot_name(std::string * slot_name)1359 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::set_allocated_slot_name(std::string* slot_name) {
1360 _impl_.slot_name_.SetAllocated(slot_name, GetArenaForAllocation());
1361 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1362 if (_impl_.slot_name_.IsDefault()) {
1363 _impl_.slot_name_.Set("", GetArenaForAllocation());
1364 }
1365 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1366 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name)
1367 }
1368
1369 // int32 slot_variable_node_id = 3;
clear_slot_variable_node_id()1370 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::clear_slot_variable_node_id() {
1371 _impl_.slot_variable_node_id_ = 0;
1372 }
_internal_slot_variable_node_id()1373 inline ::int32_t TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_slot_variable_node_id() const {
1374 return _impl_.slot_variable_node_id_;
1375 }
slot_variable_node_id()1376 inline ::int32_t TrackableObjectGraph_TrackableObject_SlotVariableReference::slot_variable_node_id() const {
1377 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_variable_node_id)
1378 return _internal_slot_variable_node_id();
1379 }
_internal_set_slot_variable_node_id(::int32_t value)1380 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::_internal_set_slot_variable_node_id(::int32_t value) {
1381
1382 _impl_.slot_variable_node_id_ = value;
1383 }
set_slot_variable_node_id(::int32_t value)1384 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::set_slot_variable_node_id(::int32_t value) {
1385 _internal_set_slot_variable_node_id(value);
1386 // @@protoc_insertion_point(field_set:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_variable_node_id)
1387 }
1388
1389 // -------------------------------------------------------------------
1390
1391 // TrackableObjectGraph_TrackableObject
1392
1393 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
_internal_children_size()1394 inline int TrackableObjectGraph_TrackableObject::_internal_children_size() const {
1395 return _impl_.children_.size();
1396 }
children_size()1397 inline int TrackableObjectGraph_TrackableObject::children_size() const {
1398 return _internal_children_size();
1399 }
clear_children()1400 inline void TrackableObjectGraph_TrackableObject::clear_children() {
1401 _impl_.children_.Clear();
1402 }
mutable_children(int index)1403 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* TrackableObjectGraph_TrackableObject::mutable_children(int index) {
1404 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.children)
1405 return _impl_.children_.Mutable(index);
1406 }
1407 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
mutable_children()1408 TrackableObjectGraph_TrackableObject::mutable_children() {
1409 // @@protoc_insertion_point(field_mutable_list:tensorflow.TrackableObjectGraph.TrackableObject.children)
1410 return &_impl_.children_;
1411 }
_internal_children(int index)1412 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& TrackableObjectGraph_TrackableObject::_internal_children(int index) const {
1413 return _impl_.children_.Get(index);
1414 }
children(int index)1415 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& TrackableObjectGraph_TrackableObject::children(int index) const {
1416 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.children)
1417 return _internal_children(index);
1418 }
_internal_add_children()1419 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* TrackableObjectGraph_TrackableObject::_internal_add_children() {
1420 return _impl_.children_.Add();
1421 }
add_children()1422 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* TrackableObjectGraph_TrackableObject::add_children() {
1423 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _add = _internal_add_children();
1424 // @@protoc_insertion_point(field_add:tensorflow.TrackableObjectGraph.TrackableObject.children)
1425 return _add;
1426 }
1427 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
children()1428 TrackableObjectGraph_TrackableObject::children() const {
1429 // @@protoc_insertion_point(field_list:tensorflow.TrackableObjectGraph.TrackableObject.children)
1430 return _impl_.children_;
1431 }
1432
1433 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor attributes = 2;
_internal_attributes_size()1434 inline int TrackableObjectGraph_TrackableObject::_internal_attributes_size() const {
1435 return _impl_.attributes_.size();
1436 }
attributes_size()1437 inline int TrackableObjectGraph_TrackableObject::attributes_size() const {
1438 return _internal_attributes_size();
1439 }
clear_attributes()1440 inline void TrackableObjectGraph_TrackableObject::clear_attributes() {
1441 _impl_.attributes_.Clear();
1442 }
mutable_attributes(int index)1443 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* TrackableObjectGraph_TrackableObject::mutable_attributes(int index) {
1444 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.attributes)
1445 return _impl_.attributes_.Mutable(index);
1446 }
1447 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >*
mutable_attributes()1448 TrackableObjectGraph_TrackableObject::mutable_attributes() {
1449 // @@protoc_insertion_point(field_mutable_list:tensorflow.TrackableObjectGraph.TrackableObject.attributes)
1450 return &_impl_.attributes_;
1451 }
_internal_attributes(int index)1452 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor& TrackableObjectGraph_TrackableObject::_internal_attributes(int index) const {
1453 return _impl_.attributes_.Get(index);
1454 }
attributes(int index)1455 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor& TrackableObjectGraph_TrackableObject::attributes(int index) const {
1456 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.attributes)
1457 return _internal_attributes(index);
1458 }
_internal_add_attributes()1459 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* TrackableObjectGraph_TrackableObject::_internal_add_attributes() {
1460 return _impl_.attributes_.Add();
1461 }
add_attributes()1462 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* TrackableObjectGraph_TrackableObject::add_attributes() {
1463 ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor* _add = _internal_add_attributes();
1464 // @@protoc_insertion_point(field_add:tensorflow.TrackableObjectGraph.TrackableObject.attributes)
1465 return _add;
1466 }
1467 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >&
attributes()1468 TrackableObjectGraph_TrackableObject::attributes() const {
1469 // @@protoc_insertion_point(field_list:tensorflow.TrackableObjectGraph.TrackableObject.attributes)
1470 return _impl_.attributes_;
1471 }
1472
1473 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
_internal_slot_variables_size()1474 inline int TrackableObjectGraph_TrackableObject::_internal_slot_variables_size() const {
1475 return _impl_.slot_variables_.size();
1476 }
slot_variables_size()1477 inline int TrackableObjectGraph_TrackableObject::slot_variables_size() const {
1478 return _internal_slot_variables_size();
1479 }
clear_slot_variables()1480 inline void TrackableObjectGraph_TrackableObject::clear_slot_variables() {
1481 _impl_.slot_variables_.Clear();
1482 }
mutable_slot_variables(int index)1483 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* TrackableObjectGraph_TrackableObject::mutable_slot_variables(int index) {
1484 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.slot_variables)
1485 return _impl_.slot_variables_.Mutable(index);
1486 }
1487 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >*
mutable_slot_variables()1488 TrackableObjectGraph_TrackableObject::mutable_slot_variables() {
1489 // @@protoc_insertion_point(field_mutable_list:tensorflow.TrackableObjectGraph.TrackableObject.slot_variables)
1490 return &_impl_.slot_variables_;
1491 }
_internal_slot_variables(int index)1492 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& TrackableObjectGraph_TrackableObject::_internal_slot_variables(int index) const {
1493 return _impl_.slot_variables_.Get(index);
1494 }
slot_variables(int index)1495 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& TrackableObjectGraph_TrackableObject::slot_variables(int index) const {
1496 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.slot_variables)
1497 return _internal_slot_variables(index);
1498 }
_internal_add_slot_variables()1499 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* TrackableObjectGraph_TrackableObject::_internal_add_slot_variables() {
1500 return _impl_.slot_variables_.Add();
1501 }
add_slot_variables()1502 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* TrackableObjectGraph_TrackableObject::add_slot_variables() {
1503 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* _add = _internal_add_slot_variables();
1504 // @@protoc_insertion_point(field_add:tensorflow.TrackableObjectGraph.TrackableObject.slot_variables)
1505 return _add;
1506 }
1507 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >&
slot_variables()1508 TrackableObjectGraph_TrackableObject::slot_variables() const {
1509 // @@protoc_insertion_point(field_list:tensorflow.TrackableObjectGraph.TrackableObject.slot_variables)
1510 return _impl_.slot_variables_;
1511 }
1512
1513 // .tensorflow.RegisteredSaver registered_saver = 4;
_internal_has_registered_saver()1514 inline bool TrackableObjectGraph_TrackableObject::_internal_has_registered_saver() const {
1515 return this != internal_default_instance() && _impl_.registered_saver_ != nullptr;
1516 }
has_registered_saver()1517 inline bool TrackableObjectGraph_TrackableObject::has_registered_saver() const {
1518 return _internal_has_registered_saver();
1519 }
clear_registered_saver()1520 inline void TrackableObjectGraph_TrackableObject::clear_registered_saver() {
1521 if (GetArenaForAllocation() == nullptr && _impl_.registered_saver_ != nullptr) {
1522 delete _impl_.registered_saver_;
1523 }
1524 _impl_.registered_saver_ = nullptr;
1525 }
_internal_registered_saver()1526 inline const ::tensorflow::RegisteredSaver& TrackableObjectGraph_TrackableObject::_internal_registered_saver() const {
1527 const ::tensorflow::RegisteredSaver* p = _impl_.registered_saver_;
1528 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::RegisteredSaver&>(
1529 ::tensorflow::_RegisteredSaver_default_instance_);
1530 }
registered_saver()1531 inline const ::tensorflow::RegisteredSaver& TrackableObjectGraph_TrackableObject::registered_saver() const {
1532 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.registered_saver)
1533 return _internal_registered_saver();
1534 }
unsafe_arena_set_allocated_registered_saver(::tensorflow::RegisteredSaver * registered_saver)1535 inline void TrackableObjectGraph_TrackableObject::unsafe_arena_set_allocated_registered_saver(
1536 ::tensorflow::RegisteredSaver* registered_saver) {
1537 if (GetArenaForAllocation() == nullptr) {
1538 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.registered_saver_);
1539 }
1540 _impl_.registered_saver_ = registered_saver;
1541 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.registered_saver)
1542 }
release_registered_saver()1543 inline ::tensorflow::RegisteredSaver* TrackableObjectGraph_TrackableObject::release_registered_saver() {
1544
1545 ::tensorflow::RegisteredSaver* temp = _impl_.registered_saver_;
1546 _impl_.registered_saver_ = nullptr;
1547 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1548 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1549 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1550 if (GetArenaForAllocation() == nullptr) { delete old; }
1551 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1552 if (GetArenaForAllocation() != nullptr) {
1553 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1554 }
1555 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1556 return temp;
1557 }
unsafe_arena_release_registered_saver()1558 inline ::tensorflow::RegisteredSaver* TrackableObjectGraph_TrackableObject::unsafe_arena_release_registered_saver() {
1559 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.registered_saver)
1560
1561 ::tensorflow::RegisteredSaver* temp = _impl_.registered_saver_;
1562 _impl_.registered_saver_ = nullptr;
1563 return temp;
1564 }
_internal_mutable_registered_saver()1565 inline ::tensorflow::RegisteredSaver* TrackableObjectGraph_TrackableObject::_internal_mutable_registered_saver() {
1566
1567 if (_impl_.registered_saver_ == nullptr) {
1568 auto* p = CreateMaybeMessage<::tensorflow::RegisteredSaver>(GetArenaForAllocation());
1569 _impl_.registered_saver_ = p;
1570 }
1571 return _impl_.registered_saver_;
1572 }
mutable_registered_saver()1573 inline ::tensorflow::RegisteredSaver* TrackableObjectGraph_TrackableObject::mutable_registered_saver() {
1574 ::tensorflow::RegisteredSaver* _msg = _internal_mutable_registered_saver();
1575 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.registered_saver)
1576 return _msg;
1577 }
set_allocated_registered_saver(::tensorflow::RegisteredSaver * registered_saver)1578 inline void TrackableObjectGraph_TrackableObject::set_allocated_registered_saver(::tensorflow::RegisteredSaver* registered_saver) {
1579 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1580 if (message_arena == nullptr) {
1581 delete _impl_.registered_saver_;
1582 }
1583 if (registered_saver) {
1584 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1585 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(registered_saver);
1586 if (message_arena != submessage_arena) {
1587 registered_saver = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1588 message_arena, registered_saver, submessage_arena);
1589 }
1590
1591 } else {
1592
1593 }
1594 _impl_.registered_saver_ = registered_saver;
1595 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.registered_saver)
1596 }
1597
1598 // .google.protobuf.BoolValue has_checkpoint_values = 5;
_internal_has_has_checkpoint_values()1599 inline bool TrackableObjectGraph_TrackableObject::_internal_has_has_checkpoint_values() const {
1600 return this != internal_default_instance() && _impl_.has_checkpoint_values_ != nullptr;
1601 }
has_has_checkpoint_values()1602 inline bool TrackableObjectGraph_TrackableObject::has_has_checkpoint_values() const {
1603 return _internal_has_has_checkpoint_values();
1604 }
_internal_has_checkpoint_values()1605 inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& TrackableObjectGraph_TrackableObject::_internal_has_checkpoint_values() const {
1606 const ::PROTOBUF_NAMESPACE_ID::BoolValue* p = _impl_.has_checkpoint_values_;
1607 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::BoolValue&>(
1608 ::PROTOBUF_NAMESPACE_ID::_BoolValue_default_instance_);
1609 }
has_checkpoint_values()1610 inline const ::PROTOBUF_NAMESPACE_ID::BoolValue& TrackableObjectGraph_TrackableObject::has_checkpoint_values() const {
1611 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.TrackableObject.has_checkpoint_values)
1612 return _internal_has_checkpoint_values();
1613 }
unsafe_arena_set_allocated_has_checkpoint_values(::PROTOBUF_NAMESPACE_ID::BoolValue * has_checkpoint_values)1614 inline void TrackableObjectGraph_TrackableObject::unsafe_arena_set_allocated_has_checkpoint_values(
1615 ::PROTOBUF_NAMESPACE_ID::BoolValue* has_checkpoint_values) {
1616 if (GetArenaForAllocation() == nullptr) {
1617 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.has_checkpoint_values_);
1618 }
1619 _impl_.has_checkpoint_values_ = has_checkpoint_values;
1620 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.has_checkpoint_values)
1621 }
release_has_checkpoint_values()1622 inline ::PROTOBUF_NAMESPACE_ID::BoolValue* TrackableObjectGraph_TrackableObject::release_has_checkpoint_values() {
1623
1624 ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.has_checkpoint_values_;
1625 _impl_.has_checkpoint_values_ = nullptr;
1626 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1627 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1628 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1629 if (GetArenaForAllocation() == nullptr) { delete old; }
1630 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1631 if (GetArenaForAllocation() != nullptr) {
1632 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1633 }
1634 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1635 return temp;
1636 }
unsafe_arena_release_has_checkpoint_values()1637 inline ::PROTOBUF_NAMESPACE_ID::BoolValue* TrackableObjectGraph_TrackableObject::unsafe_arena_release_has_checkpoint_values() {
1638 // @@protoc_insertion_point(field_release:tensorflow.TrackableObjectGraph.TrackableObject.has_checkpoint_values)
1639
1640 ::PROTOBUF_NAMESPACE_ID::BoolValue* temp = _impl_.has_checkpoint_values_;
1641 _impl_.has_checkpoint_values_ = nullptr;
1642 return temp;
1643 }
_internal_mutable_has_checkpoint_values()1644 inline ::PROTOBUF_NAMESPACE_ID::BoolValue* TrackableObjectGraph_TrackableObject::_internal_mutable_has_checkpoint_values() {
1645
1646 if (_impl_.has_checkpoint_values_ == nullptr) {
1647 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(GetArenaForAllocation());
1648 _impl_.has_checkpoint_values_ = p;
1649 }
1650 return _impl_.has_checkpoint_values_;
1651 }
mutable_has_checkpoint_values()1652 inline ::PROTOBUF_NAMESPACE_ID::BoolValue* TrackableObjectGraph_TrackableObject::mutable_has_checkpoint_values() {
1653 ::PROTOBUF_NAMESPACE_ID::BoolValue* _msg = _internal_mutable_has_checkpoint_values();
1654 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.TrackableObject.has_checkpoint_values)
1655 return _msg;
1656 }
set_allocated_has_checkpoint_values(::PROTOBUF_NAMESPACE_ID::BoolValue * has_checkpoint_values)1657 inline void TrackableObjectGraph_TrackableObject::set_allocated_has_checkpoint_values(::PROTOBUF_NAMESPACE_ID::BoolValue* has_checkpoint_values) {
1658 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1659 if (message_arena == nullptr) {
1660 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.has_checkpoint_values_);
1661 }
1662 if (has_checkpoint_values) {
1663 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1664 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
1665 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(has_checkpoint_values));
1666 if (message_arena != submessage_arena) {
1667 has_checkpoint_values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1668 message_arena, has_checkpoint_values, submessage_arena);
1669 }
1670
1671 } else {
1672
1673 }
1674 _impl_.has_checkpoint_values_ = has_checkpoint_values;
1675 // @@protoc_insertion_point(field_set_allocated:tensorflow.TrackableObjectGraph.TrackableObject.has_checkpoint_values)
1676 }
1677
1678 // -------------------------------------------------------------------
1679
1680 // TrackableObjectGraph
1681
1682 // repeated .tensorflow.TrackableObjectGraph.TrackableObject nodes = 1;
_internal_nodes_size()1683 inline int TrackableObjectGraph::_internal_nodes_size() const {
1684 return _impl_.nodes_.size();
1685 }
nodes_size()1686 inline int TrackableObjectGraph::nodes_size() const {
1687 return _internal_nodes_size();
1688 }
clear_nodes()1689 inline void TrackableObjectGraph::clear_nodes() {
1690 _impl_.nodes_.Clear();
1691 }
mutable_nodes(int index)1692 inline ::tensorflow::TrackableObjectGraph_TrackableObject* TrackableObjectGraph::mutable_nodes(int index) {
1693 // @@protoc_insertion_point(field_mutable:tensorflow.TrackableObjectGraph.nodes)
1694 return _impl_.nodes_.Mutable(index);
1695 }
1696 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject >*
mutable_nodes()1697 TrackableObjectGraph::mutable_nodes() {
1698 // @@protoc_insertion_point(field_mutable_list:tensorflow.TrackableObjectGraph.nodes)
1699 return &_impl_.nodes_;
1700 }
_internal_nodes(int index)1701 inline const ::tensorflow::TrackableObjectGraph_TrackableObject& TrackableObjectGraph::_internal_nodes(int index) const {
1702 return _impl_.nodes_.Get(index);
1703 }
nodes(int index)1704 inline const ::tensorflow::TrackableObjectGraph_TrackableObject& TrackableObjectGraph::nodes(int index) const {
1705 // @@protoc_insertion_point(field_get:tensorflow.TrackableObjectGraph.nodes)
1706 return _internal_nodes(index);
1707 }
_internal_add_nodes()1708 inline ::tensorflow::TrackableObjectGraph_TrackableObject* TrackableObjectGraph::_internal_add_nodes() {
1709 return _impl_.nodes_.Add();
1710 }
add_nodes()1711 inline ::tensorflow::TrackableObjectGraph_TrackableObject* TrackableObjectGraph::add_nodes() {
1712 ::tensorflow::TrackableObjectGraph_TrackableObject* _add = _internal_add_nodes();
1713 // @@protoc_insertion_point(field_add:tensorflow.TrackableObjectGraph.nodes)
1714 return _add;
1715 }
1716 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject >&
nodes()1717 TrackableObjectGraph::nodes() const {
1718 // @@protoc_insertion_point(field_list:tensorflow.TrackableObjectGraph.nodes)
1719 return _impl_.nodes_;
1720 }
1721
1722 // -------------------------------------------------------------------
1723
1724 // RegisteredSaver
1725
1726 // string name = 1;
clear_name()1727 inline void RegisteredSaver::clear_name() {
1728 _impl_.name_.ClearToEmpty();
1729 }
name()1730 inline const std::string& RegisteredSaver::name() const {
1731 // @@protoc_insertion_point(field_get:tensorflow.RegisteredSaver.name)
1732 return _internal_name();
1733 }
1734 template <typename ArgT0, typename... ArgT>
1735 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)1736 void RegisteredSaver::set_name(ArgT0&& arg0, ArgT... args) {
1737
1738 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1739 // @@protoc_insertion_point(field_set:tensorflow.RegisteredSaver.name)
1740 }
mutable_name()1741 inline std::string* RegisteredSaver::mutable_name() {
1742 std::string* _s = _internal_mutable_name();
1743 // @@protoc_insertion_point(field_mutable:tensorflow.RegisteredSaver.name)
1744 return _s;
1745 }
_internal_name()1746 inline const std::string& RegisteredSaver::_internal_name() const {
1747 return _impl_.name_.Get();
1748 }
_internal_set_name(const std::string & value)1749 inline void RegisteredSaver::_internal_set_name(const std::string& value) {
1750
1751 _impl_.name_.Set(value, GetArenaForAllocation());
1752 }
_internal_mutable_name()1753 inline std::string* RegisteredSaver::_internal_mutable_name() {
1754
1755 return _impl_.name_.Mutable(GetArenaForAllocation());
1756 }
release_name()1757 inline std::string* RegisteredSaver::release_name() {
1758 // @@protoc_insertion_point(field_release:tensorflow.RegisteredSaver.name)
1759 return _impl_.name_.Release();
1760 }
set_allocated_name(std::string * name)1761 inline void RegisteredSaver::set_allocated_name(std::string* name) {
1762 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
1763 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1764 if (_impl_.name_.IsDefault()) {
1765 _impl_.name_.Set("", GetArenaForAllocation());
1766 }
1767 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1768 // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisteredSaver.name)
1769 }
1770
1771 // string object_name = 2;
clear_object_name()1772 inline void RegisteredSaver::clear_object_name() {
1773 _impl_.object_name_.ClearToEmpty();
1774 }
object_name()1775 inline const std::string& RegisteredSaver::object_name() const {
1776 // @@protoc_insertion_point(field_get:tensorflow.RegisteredSaver.object_name)
1777 return _internal_object_name();
1778 }
1779 template <typename ArgT0, typename... ArgT>
1780 inline PROTOBUF_ALWAYS_INLINE
set_object_name(ArgT0 && arg0,ArgT...args)1781 void RegisteredSaver::set_object_name(ArgT0&& arg0, ArgT... args) {
1782
1783 _impl_.object_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1784 // @@protoc_insertion_point(field_set:tensorflow.RegisteredSaver.object_name)
1785 }
mutable_object_name()1786 inline std::string* RegisteredSaver::mutable_object_name() {
1787 std::string* _s = _internal_mutable_object_name();
1788 // @@protoc_insertion_point(field_mutable:tensorflow.RegisteredSaver.object_name)
1789 return _s;
1790 }
_internal_object_name()1791 inline const std::string& RegisteredSaver::_internal_object_name() const {
1792 return _impl_.object_name_.Get();
1793 }
_internal_set_object_name(const std::string & value)1794 inline void RegisteredSaver::_internal_set_object_name(const std::string& value) {
1795
1796 _impl_.object_name_.Set(value, GetArenaForAllocation());
1797 }
_internal_mutable_object_name()1798 inline std::string* RegisteredSaver::_internal_mutable_object_name() {
1799
1800 return _impl_.object_name_.Mutable(GetArenaForAllocation());
1801 }
release_object_name()1802 inline std::string* RegisteredSaver::release_object_name() {
1803 // @@protoc_insertion_point(field_release:tensorflow.RegisteredSaver.object_name)
1804 return _impl_.object_name_.Release();
1805 }
set_allocated_object_name(std::string * object_name)1806 inline void RegisteredSaver::set_allocated_object_name(std::string* object_name) {
1807 _impl_.object_name_.SetAllocated(object_name, GetArenaForAllocation());
1808 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1809 if (_impl_.object_name_.IsDefault()) {
1810 _impl_.object_name_.Set("", GetArenaForAllocation());
1811 }
1812 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1813 // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisteredSaver.object_name)
1814 }
1815
1816 #ifdef __GNUC__
1817 #pragma GCC diagnostic pop
1818 #endif // __GNUC__
1819 // -------------------------------------------------------------------
1820
1821 // -------------------------------------------------------------------
1822
1823 // -------------------------------------------------------------------
1824
1825 // -------------------------------------------------------------------
1826
1827 // -------------------------------------------------------------------
1828
1829
1830 // @@protoc_insertion_point(namespace_scope)
1831
1832 } // namespace tensorflow
1833
1834 // @@protoc_insertion_point(global_scope)
1835
1836 #include <google/protobuf/port_undef.inc>
1837 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2ftrackable_5fobject_5fgraph_2eproto
1838