1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/trackable_object_graph.proto
3
4 #include "tensorflow/core/protobuf/trackable_object_graph.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace tensorflow {
TrackableObjectGraph_TrackableObject_ObjectReference(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_ObjectReference::TrackableObjectGraph_TrackableObject_ObjectReference(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.local_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
25 , /*decltype(_impl_.node_id_)*/0
26 , /*decltype(_impl_._cached_size_)*/{}} {}
27 struct TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal {
TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal28 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal()
29 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal30 ~TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal() {}
31 union { // NOLINT(misc-non-private-member-variables-in-classes)
32 TrackableObjectGraph_TrackableObject_ObjectReference _instance;
33 };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackableObjectGraph_TrackableObject_ObjectReferenceDefaultTypeInternal _TrackableObjectGraph_TrackableObject_ObjectReference_default_instance_;
TrackableObjectGraph_TrackableObject_SerializedTensor(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SerializedTensor::TrackableObjectGraph_TrackableObject_SerializedTensor(
37 ::_pbi::ConstantInitialized): _impl_{
38 /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
39 , /*decltype(_impl_.full_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40 , /*decltype(_impl_.checkpoint_key_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
41 , /*decltype(_impl_._cached_size_)*/{}} {}
42 struct TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal {
TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal43 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal()
44 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal45 ~TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal() {}
46 union { // NOLINT(misc-non-private-member-variables-in-classes)
47 TrackableObjectGraph_TrackableObject_SerializedTensor _instance;
48 };
49 };
50 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackableObjectGraph_TrackableObject_SerializedTensorDefaultTypeInternal _TrackableObjectGraph_TrackableObject_SerializedTensor_default_instance_;
TrackableObjectGraph_TrackableObject_SlotVariableReference(::_pbi::ConstantInitialized)51 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SlotVariableReference::TrackableObjectGraph_TrackableObject_SlotVariableReference(
52 ::_pbi::ConstantInitialized): _impl_{
53 /*decltype(_impl_.slot_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
54 , /*decltype(_impl_.original_variable_node_id_)*/0
55 , /*decltype(_impl_.slot_variable_node_id_)*/0
56 , /*decltype(_impl_._cached_size_)*/{}} {}
57 struct TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal {
TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal58 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal()
59 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal60 ~TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal() {}
61 union { // NOLINT(misc-non-private-member-variables-in-classes)
62 TrackableObjectGraph_TrackableObject_SlotVariableReference _instance;
63 };
64 };
65 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackableObjectGraph_TrackableObject_SlotVariableReferenceDefaultTypeInternal _TrackableObjectGraph_TrackableObject_SlotVariableReference_default_instance_;
TrackableObjectGraph_TrackableObject(::_pbi::ConstantInitialized)66 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObject::TrackableObjectGraph_TrackableObject(
67 ::_pbi::ConstantInitialized): _impl_{
68 /*decltype(_impl_.children_)*/{}
69 , /*decltype(_impl_.attributes_)*/{}
70 , /*decltype(_impl_.slot_variables_)*/{}
71 , /*decltype(_impl_.registered_saver_)*/nullptr
72 , /*decltype(_impl_.has_checkpoint_values_)*/nullptr
73 , /*decltype(_impl_._cached_size_)*/{}} {}
74 struct TrackableObjectGraph_TrackableObjectDefaultTypeInternal {
TrackableObjectGraph_TrackableObjectDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObjectDefaultTypeInternal75 PROTOBUF_CONSTEXPR TrackableObjectGraph_TrackableObjectDefaultTypeInternal()
76 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackableObjectGraph_TrackableObjectDefaultTypeInternaltensorflow::TrackableObjectGraph_TrackableObjectDefaultTypeInternal77 ~TrackableObjectGraph_TrackableObjectDefaultTypeInternal() {}
78 union { // NOLINT(misc-non-private-member-variables-in-classes)
79 TrackableObjectGraph_TrackableObject _instance;
80 };
81 };
82 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackableObjectGraph_TrackableObjectDefaultTypeInternal _TrackableObjectGraph_TrackableObject_default_instance_;
TrackableObjectGraph(::_pbi::ConstantInitialized)83 PROTOBUF_CONSTEXPR TrackableObjectGraph::TrackableObjectGraph(
84 ::_pbi::ConstantInitialized): _impl_{
85 /*decltype(_impl_.nodes_)*/{}
86 , /*decltype(_impl_._cached_size_)*/{}} {}
87 struct TrackableObjectGraphDefaultTypeInternal {
TrackableObjectGraphDefaultTypeInternaltensorflow::TrackableObjectGraphDefaultTypeInternal88 PROTOBUF_CONSTEXPR TrackableObjectGraphDefaultTypeInternal()
89 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackableObjectGraphDefaultTypeInternaltensorflow::TrackableObjectGraphDefaultTypeInternal90 ~TrackableObjectGraphDefaultTypeInternal() {}
91 union { // NOLINT(misc-non-private-member-variables-in-classes)
92 TrackableObjectGraph _instance;
93 };
94 };
95 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackableObjectGraphDefaultTypeInternal _TrackableObjectGraph_default_instance_;
RegisteredSaver(::_pbi::ConstantInitialized)96 PROTOBUF_CONSTEXPR RegisteredSaver::RegisteredSaver(
97 ::_pbi::ConstantInitialized): _impl_{
98 /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
99 , /*decltype(_impl_.object_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
100 , /*decltype(_impl_._cached_size_)*/{}} {}
101 struct RegisteredSaverDefaultTypeInternal {
RegisteredSaverDefaultTypeInternaltensorflow::RegisteredSaverDefaultTypeInternal102 PROTOBUF_CONSTEXPR RegisteredSaverDefaultTypeInternal()
103 : _instance(::_pbi::ConstantInitialized{}) {}
~RegisteredSaverDefaultTypeInternaltensorflow::RegisteredSaverDefaultTypeInternal104 ~RegisteredSaverDefaultTypeInternal() {}
105 union { // NOLINT(misc-non-private-member-variables-in-classes)
106 RegisteredSaver _instance;
107 };
108 };
109 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegisteredSaverDefaultTypeInternal _RegisteredSaver_default_instance_;
110 } // namespace tensorflow
111 namespace tensorflow {
112
113 // ===================================================================
114
115 class TrackableObjectGraph_TrackableObject_ObjectReference::_Internal {
116 public:
117 };
118
TrackableObjectGraph_TrackableObject_ObjectReference(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)119 TrackableObjectGraph_TrackableObject_ObjectReference::TrackableObjectGraph_TrackableObject_ObjectReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
120 bool is_message_owned)
121 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
122 SharedCtor(arena, is_message_owned);
123 // @@protoc_insertion_point(arena_constructor:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
124 }
TrackableObjectGraph_TrackableObject_ObjectReference(const TrackableObjectGraph_TrackableObject_ObjectReference & from)125 TrackableObjectGraph_TrackableObject_ObjectReference::TrackableObjectGraph_TrackableObject_ObjectReference(const TrackableObjectGraph_TrackableObject_ObjectReference& from)
126 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
127 TrackableObjectGraph_TrackableObject_ObjectReference* const _this = this; (void)_this;
128 new (&_impl_) Impl_{
129 decltype(_impl_.local_name_){}
130 , decltype(_impl_.node_id_){}
131 , /*decltype(_impl_._cached_size_)*/{}};
132
133 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
134 _impl_.local_name_.InitDefault();
135 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
136 _impl_.local_name_.Set("", GetArenaForAllocation());
137 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
138 if (!from._internal_local_name().empty()) {
139 _this->_impl_.local_name_.Set(from._internal_local_name(),
140 _this->GetArenaForAllocation());
141 }
142 _this->_impl_.node_id_ = from._impl_.node_id_;
143 // @@protoc_insertion_point(copy_constructor:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
144 }
145
SharedCtor(::_pb::Arena * arena,bool is_message_owned)146 inline void TrackableObjectGraph_TrackableObject_ObjectReference::SharedCtor(
147 ::_pb::Arena* arena, bool is_message_owned) {
148 (void)arena;
149 (void)is_message_owned;
150 new (&_impl_) Impl_{
151 decltype(_impl_.local_name_){}
152 , decltype(_impl_.node_id_){0}
153 , /*decltype(_impl_._cached_size_)*/{}
154 };
155 _impl_.local_name_.InitDefault();
156 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
157 _impl_.local_name_.Set("", GetArenaForAllocation());
158 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
159 }
160
~TrackableObjectGraph_TrackableObject_ObjectReference()161 TrackableObjectGraph_TrackableObject_ObjectReference::~TrackableObjectGraph_TrackableObject_ObjectReference() {
162 // @@protoc_insertion_point(destructor:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
163 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
164 (void)arena;
165 return;
166 }
167 SharedDtor();
168 }
169
SharedDtor()170 inline void TrackableObjectGraph_TrackableObject_ObjectReference::SharedDtor() {
171 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
172 _impl_.local_name_.Destroy();
173 }
174
SetCachedSize(int size) const175 void TrackableObjectGraph_TrackableObject_ObjectReference::SetCachedSize(int size) const {
176 _impl_._cached_size_.Set(size);
177 }
178
Clear()179 void TrackableObjectGraph_TrackableObject_ObjectReference::Clear() {
180 // @@protoc_insertion_point(message_clear_start:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
181 ::uint32_t cached_has_bits = 0;
182 // Prevent compiler warnings about cached_has_bits being unused
183 (void) cached_has_bits;
184
185 _impl_.local_name_.ClearToEmpty();
186 _impl_.node_id_ = 0;
187 _internal_metadata_.Clear<std::string>();
188 }
189
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)190 const char* TrackableObjectGraph_TrackableObject_ObjectReference::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
191 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
192 while (!ctx->Done(&ptr)) {
193 ::uint32_t tag;
194 ptr = ::_pbi::ReadTag(ptr, &tag);
195 switch (tag >> 3) {
196 // int32 node_id = 1;
197 case 1:
198 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
199 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
200 CHK_(ptr);
201 } else {
202 goto handle_unusual;
203 }
204 continue;
205 // string local_name = 2;
206 case 2:
207 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
208 auto str = _internal_mutable_local_name();
209 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
210 CHK_(ptr);
211 CHK_(::_pbi::VerifyUTF8(str, nullptr));
212 } else {
213 goto handle_unusual;
214 }
215 continue;
216 default:
217 goto handle_unusual;
218 } // switch
219 handle_unusual:
220 if ((tag == 0) || ((tag & 7) == 4)) {
221 CHK_(ptr);
222 ctx->SetLastTag(tag);
223 goto message_done;
224 }
225 ptr = UnknownFieldParse(
226 tag,
227 _internal_metadata_.mutable_unknown_fields<std::string>(),
228 ptr, ctx);
229 CHK_(ptr != nullptr);
230 } // while
231 message_done:
232 return ptr;
233 failure:
234 ptr = nullptr;
235 goto message_done;
236 #undef CHK_
237 }
238
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const239 ::uint8_t* TrackableObjectGraph_TrackableObject_ObjectReference::_InternalSerialize(
240 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
241 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
242 ::uint32_t cached_has_bits = 0;
243 (void) cached_has_bits;
244
245 // int32 node_id = 1;
246 if (this->_internal_node_id() != 0) {
247 target = stream->EnsureSpace(target);
248 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_node_id(), target);
249 }
250
251 // string local_name = 2;
252 if (!this->_internal_local_name().empty()) {
253 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
254 this->_internal_local_name().data(), static_cast<int>(this->_internal_local_name().length()),
255 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
256 "tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference.local_name");
257 target = stream->WriteStringMaybeAliased(
258 2, this->_internal_local_name(), target);
259 }
260
261 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
262 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
263 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
264 }
265 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
266 return target;
267 }
268
ByteSizeLong() const269 size_t TrackableObjectGraph_TrackableObject_ObjectReference::ByteSizeLong() const {
270 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
271 size_t total_size = 0;
272
273 ::uint32_t cached_has_bits = 0;
274 // Prevent compiler warnings about cached_has_bits being unused
275 (void) cached_has_bits;
276
277 // string local_name = 2;
278 if (!this->_internal_local_name().empty()) {
279 total_size += 1 +
280 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
281 this->_internal_local_name());
282 }
283
284 // int32 node_id = 1;
285 if (this->_internal_node_id() != 0) {
286 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
287 }
288
289 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
290 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
291 }
292 int cached_size = ::_pbi::ToCachedSize(total_size);
293 SetCachedSize(cached_size);
294 return total_size;
295 }
296
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)297 void TrackableObjectGraph_TrackableObject_ObjectReference::CheckTypeAndMergeFrom(
298 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
299 MergeFrom(*::_pbi::DownCast<const TrackableObjectGraph_TrackableObject_ObjectReference*>(
300 &from));
301 }
302
MergeFrom(const TrackableObjectGraph_TrackableObject_ObjectReference & from)303 void TrackableObjectGraph_TrackableObject_ObjectReference::MergeFrom(const TrackableObjectGraph_TrackableObject_ObjectReference& from) {
304 TrackableObjectGraph_TrackableObject_ObjectReference* const _this = this;
305 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
306 GOOGLE_DCHECK_NE(&from, _this);
307 ::uint32_t cached_has_bits = 0;
308 (void) cached_has_bits;
309
310 if (!from._internal_local_name().empty()) {
311 _this->_internal_set_local_name(from._internal_local_name());
312 }
313 if (from._internal_node_id() != 0) {
314 _this->_internal_set_node_id(from._internal_node_id());
315 }
316 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
317 }
318
CopyFrom(const TrackableObjectGraph_TrackableObject_ObjectReference & from)319 void TrackableObjectGraph_TrackableObject_ObjectReference::CopyFrom(const TrackableObjectGraph_TrackableObject_ObjectReference& from) {
320 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference)
321 if (&from == this) return;
322 Clear();
323 MergeFrom(from);
324 }
325
IsInitialized() const326 bool TrackableObjectGraph_TrackableObject_ObjectReference::IsInitialized() const {
327 return true;
328 }
329
InternalSwap(TrackableObjectGraph_TrackableObject_ObjectReference * other)330 void TrackableObjectGraph_TrackableObject_ObjectReference::InternalSwap(TrackableObjectGraph_TrackableObject_ObjectReference* other) {
331 using std::swap;
332 auto* lhs_arena = GetArenaForAllocation();
333 auto* rhs_arena = other->GetArenaForAllocation();
334 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
335 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
336 &_impl_.local_name_, lhs_arena,
337 &other->_impl_.local_name_, rhs_arena
338 );
339 swap(_impl_.node_id_, other->_impl_.node_id_);
340 }
341
GetTypeName() const342 std::string TrackableObjectGraph_TrackableObject_ObjectReference::GetTypeName() const {
343 return "tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference";
344 }
345
346
347 // ===================================================================
348
349 class TrackableObjectGraph_TrackableObject_SerializedTensor::_Internal {
350 public:
351 };
352
TrackableObjectGraph_TrackableObject_SerializedTensor(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)353 TrackableObjectGraph_TrackableObject_SerializedTensor::TrackableObjectGraph_TrackableObject_SerializedTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
354 bool is_message_owned)
355 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
356 SharedCtor(arena, is_message_owned);
357 // @@protoc_insertion_point(arena_constructor:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
358 }
TrackableObjectGraph_TrackableObject_SerializedTensor(const TrackableObjectGraph_TrackableObject_SerializedTensor & from)359 TrackableObjectGraph_TrackableObject_SerializedTensor::TrackableObjectGraph_TrackableObject_SerializedTensor(const TrackableObjectGraph_TrackableObject_SerializedTensor& from)
360 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
361 TrackableObjectGraph_TrackableObject_SerializedTensor* const _this = this; (void)_this;
362 new (&_impl_) Impl_{
363 decltype(_impl_.name_){}
364 , decltype(_impl_.full_name_){}
365 , decltype(_impl_.checkpoint_key_){}
366 , /*decltype(_impl_._cached_size_)*/{}};
367
368 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
369 _impl_.name_.InitDefault();
370 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
371 _impl_.name_.Set("", GetArenaForAllocation());
372 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
373 if (!from._internal_name().empty()) {
374 _this->_impl_.name_.Set(from._internal_name(),
375 _this->GetArenaForAllocation());
376 }
377 _impl_.full_name_.InitDefault();
378 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
379 _impl_.full_name_.Set("", GetArenaForAllocation());
380 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
381 if (!from._internal_full_name().empty()) {
382 _this->_impl_.full_name_.Set(from._internal_full_name(),
383 _this->GetArenaForAllocation());
384 }
385 _impl_.checkpoint_key_.InitDefault();
386 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
387 _impl_.checkpoint_key_.Set("", GetArenaForAllocation());
388 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
389 if (!from._internal_checkpoint_key().empty()) {
390 _this->_impl_.checkpoint_key_.Set(from._internal_checkpoint_key(),
391 _this->GetArenaForAllocation());
392 }
393 // @@protoc_insertion_point(copy_constructor:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
394 }
395
SharedCtor(::_pb::Arena * arena,bool is_message_owned)396 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::SharedCtor(
397 ::_pb::Arena* arena, bool is_message_owned) {
398 (void)arena;
399 (void)is_message_owned;
400 new (&_impl_) Impl_{
401 decltype(_impl_.name_){}
402 , decltype(_impl_.full_name_){}
403 , decltype(_impl_.checkpoint_key_){}
404 , /*decltype(_impl_._cached_size_)*/{}
405 };
406 _impl_.name_.InitDefault();
407 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
408 _impl_.name_.Set("", GetArenaForAllocation());
409 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
410 _impl_.full_name_.InitDefault();
411 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
412 _impl_.full_name_.Set("", GetArenaForAllocation());
413 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
414 _impl_.checkpoint_key_.InitDefault();
415 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
416 _impl_.checkpoint_key_.Set("", GetArenaForAllocation());
417 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
418 }
419
~TrackableObjectGraph_TrackableObject_SerializedTensor()420 TrackableObjectGraph_TrackableObject_SerializedTensor::~TrackableObjectGraph_TrackableObject_SerializedTensor() {
421 // @@protoc_insertion_point(destructor:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
422 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
423 (void)arena;
424 return;
425 }
426 SharedDtor();
427 }
428
SharedDtor()429 inline void TrackableObjectGraph_TrackableObject_SerializedTensor::SharedDtor() {
430 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
431 _impl_.name_.Destroy();
432 _impl_.full_name_.Destroy();
433 _impl_.checkpoint_key_.Destroy();
434 }
435
SetCachedSize(int size) const436 void TrackableObjectGraph_TrackableObject_SerializedTensor::SetCachedSize(int size) const {
437 _impl_._cached_size_.Set(size);
438 }
439
Clear()440 void TrackableObjectGraph_TrackableObject_SerializedTensor::Clear() {
441 // @@protoc_insertion_point(message_clear_start:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
442 ::uint32_t cached_has_bits = 0;
443 // Prevent compiler warnings about cached_has_bits being unused
444 (void) cached_has_bits;
445
446 _impl_.name_.ClearToEmpty();
447 _impl_.full_name_.ClearToEmpty();
448 _impl_.checkpoint_key_.ClearToEmpty();
449 _internal_metadata_.Clear<std::string>();
450 }
451
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)452 const char* TrackableObjectGraph_TrackableObject_SerializedTensor::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
453 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
454 while (!ctx->Done(&ptr)) {
455 ::uint32_t tag;
456 ptr = ::_pbi::ReadTag(ptr, &tag);
457 switch (tag >> 3) {
458 // string name = 1;
459 case 1:
460 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
461 auto str = _internal_mutable_name();
462 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
463 CHK_(ptr);
464 CHK_(::_pbi::VerifyUTF8(str, nullptr));
465 } else {
466 goto handle_unusual;
467 }
468 continue;
469 // string full_name = 2;
470 case 2:
471 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
472 auto str = _internal_mutable_full_name();
473 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
474 CHK_(ptr);
475 CHK_(::_pbi::VerifyUTF8(str, nullptr));
476 } else {
477 goto handle_unusual;
478 }
479 continue;
480 // string checkpoint_key = 3;
481 case 3:
482 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
483 auto str = _internal_mutable_checkpoint_key();
484 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
485 CHK_(ptr);
486 CHK_(::_pbi::VerifyUTF8(str, nullptr));
487 } else {
488 goto handle_unusual;
489 }
490 continue;
491 default:
492 goto handle_unusual;
493 } // switch
494 handle_unusual:
495 if ((tag == 0) || ((tag & 7) == 4)) {
496 CHK_(ptr);
497 ctx->SetLastTag(tag);
498 goto message_done;
499 }
500 ptr = UnknownFieldParse(
501 tag,
502 _internal_metadata_.mutable_unknown_fields<std::string>(),
503 ptr, ctx);
504 CHK_(ptr != nullptr);
505 } // while
506 message_done:
507 return ptr;
508 failure:
509 ptr = nullptr;
510 goto message_done;
511 #undef CHK_
512 }
513
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const514 ::uint8_t* TrackableObjectGraph_TrackableObject_SerializedTensor::_InternalSerialize(
515 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
516 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
517 ::uint32_t cached_has_bits = 0;
518 (void) cached_has_bits;
519
520 // string name = 1;
521 if (!this->_internal_name().empty()) {
522 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
523 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
524 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
525 "tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.name");
526 target = stream->WriteStringMaybeAliased(
527 1, this->_internal_name(), target);
528 }
529
530 // string full_name = 2;
531 if (!this->_internal_full_name().empty()) {
532 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
533 this->_internal_full_name().data(), static_cast<int>(this->_internal_full_name().length()),
534 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
535 "tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.full_name");
536 target = stream->WriteStringMaybeAliased(
537 2, this->_internal_full_name(), target);
538 }
539
540 // string checkpoint_key = 3;
541 if (!this->_internal_checkpoint_key().empty()) {
542 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
543 this->_internal_checkpoint_key().data(), static_cast<int>(this->_internal_checkpoint_key().length()),
544 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
545 "tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor.checkpoint_key");
546 target = stream->WriteStringMaybeAliased(
547 3, this->_internal_checkpoint_key(), target);
548 }
549
550 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
551 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
552 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
553 }
554 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
555 return target;
556 }
557
ByteSizeLong() const558 size_t TrackableObjectGraph_TrackableObject_SerializedTensor::ByteSizeLong() const {
559 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
560 size_t total_size = 0;
561
562 ::uint32_t cached_has_bits = 0;
563 // Prevent compiler warnings about cached_has_bits being unused
564 (void) cached_has_bits;
565
566 // string name = 1;
567 if (!this->_internal_name().empty()) {
568 total_size += 1 +
569 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
570 this->_internal_name());
571 }
572
573 // string full_name = 2;
574 if (!this->_internal_full_name().empty()) {
575 total_size += 1 +
576 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
577 this->_internal_full_name());
578 }
579
580 // string checkpoint_key = 3;
581 if (!this->_internal_checkpoint_key().empty()) {
582 total_size += 1 +
583 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
584 this->_internal_checkpoint_key());
585 }
586
587 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
588 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
589 }
590 int cached_size = ::_pbi::ToCachedSize(total_size);
591 SetCachedSize(cached_size);
592 return total_size;
593 }
594
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)595 void TrackableObjectGraph_TrackableObject_SerializedTensor::CheckTypeAndMergeFrom(
596 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
597 MergeFrom(*::_pbi::DownCast<const TrackableObjectGraph_TrackableObject_SerializedTensor*>(
598 &from));
599 }
600
MergeFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor & from)601 void TrackableObjectGraph_TrackableObject_SerializedTensor::MergeFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor& from) {
602 TrackableObjectGraph_TrackableObject_SerializedTensor* const _this = this;
603 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
604 GOOGLE_DCHECK_NE(&from, _this);
605 ::uint32_t cached_has_bits = 0;
606 (void) cached_has_bits;
607
608 if (!from._internal_name().empty()) {
609 _this->_internal_set_name(from._internal_name());
610 }
611 if (!from._internal_full_name().empty()) {
612 _this->_internal_set_full_name(from._internal_full_name());
613 }
614 if (!from._internal_checkpoint_key().empty()) {
615 _this->_internal_set_checkpoint_key(from._internal_checkpoint_key());
616 }
617 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
618 }
619
CopyFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor & from)620 void TrackableObjectGraph_TrackableObject_SerializedTensor::CopyFrom(const TrackableObjectGraph_TrackableObject_SerializedTensor& from) {
621 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor)
622 if (&from == this) return;
623 Clear();
624 MergeFrom(from);
625 }
626
IsInitialized() const627 bool TrackableObjectGraph_TrackableObject_SerializedTensor::IsInitialized() const {
628 return true;
629 }
630
InternalSwap(TrackableObjectGraph_TrackableObject_SerializedTensor * other)631 void TrackableObjectGraph_TrackableObject_SerializedTensor::InternalSwap(TrackableObjectGraph_TrackableObject_SerializedTensor* other) {
632 using std::swap;
633 auto* lhs_arena = GetArenaForAllocation();
634 auto* rhs_arena = other->GetArenaForAllocation();
635 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
636 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
637 &_impl_.name_, lhs_arena,
638 &other->_impl_.name_, rhs_arena
639 );
640 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
641 &_impl_.full_name_, lhs_arena,
642 &other->_impl_.full_name_, rhs_arena
643 );
644 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
645 &_impl_.checkpoint_key_, lhs_arena,
646 &other->_impl_.checkpoint_key_, rhs_arena
647 );
648 }
649
GetTypeName() const650 std::string TrackableObjectGraph_TrackableObject_SerializedTensor::GetTypeName() const {
651 return "tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor";
652 }
653
654
655 // ===================================================================
656
657 class TrackableObjectGraph_TrackableObject_SlotVariableReference::_Internal {
658 public:
659 };
660
TrackableObjectGraph_TrackableObject_SlotVariableReference(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)661 TrackableObjectGraph_TrackableObject_SlotVariableReference::TrackableObjectGraph_TrackableObject_SlotVariableReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
662 bool is_message_owned)
663 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
664 SharedCtor(arena, is_message_owned);
665 // @@protoc_insertion_point(arena_constructor:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
666 }
TrackableObjectGraph_TrackableObject_SlotVariableReference(const TrackableObjectGraph_TrackableObject_SlotVariableReference & from)667 TrackableObjectGraph_TrackableObject_SlotVariableReference::TrackableObjectGraph_TrackableObject_SlotVariableReference(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from)
668 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
669 TrackableObjectGraph_TrackableObject_SlotVariableReference* const _this = this; (void)_this;
670 new (&_impl_) Impl_{
671 decltype(_impl_.slot_name_){}
672 , decltype(_impl_.original_variable_node_id_){}
673 , decltype(_impl_.slot_variable_node_id_){}
674 , /*decltype(_impl_._cached_size_)*/{}};
675
676 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
677 _impl_.slot_name_.InitDefault();
678 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
679 _impl_.slot_name_.Set("", GetArenaForAllocation());
680 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
681 if (!from._internal_slot_name().empty()) {
682 _this->_impl_.slot_name_.Set(from._internal_slot_name(),
683 _this->GetArenaForAllocation());
684 }
685 ::memcpy(&_impl_.original_variable_node_id_, &from._impl_.original_variable_node_id_,
686 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.slot_variable_node_id_) -
687 reinterpret_cast<char*>(&_impl_.original_variable_node_id_)) + sizeof(_impl_.slot_variable_node_id_));
688 // @@protoc_insertion_point(copy_constructor:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
689 }
690
SharedCtor(::_pb::Arena * arena,bool is_message_owned)691 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::SharedCtor(
692 ::_pb::Arena* arena, bool is_message_owned) {
693 (void)arena;
694 (void)is_message_owned;
695 new (&_impl_) Impl_{
696 decltype(_impl_.slot_name_){}
697 , decltype(_impl_.original_variable_node_id_){0}
698 , decltype(_impl_.slot_variable_node_id_){0}
699 , /*decltype(_impl_._cached_size_)*/{}
700 };
701 _impl_.slot_name_.InitDefault();
702 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
703 _impl_.slot_name_.Set("", GetArenaForAllocation());
704 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
705 }
706
~TrackableObjectGraph_TrackableObject_SlotVariableReference()707 TrackableObjectGraph_TrackableObject_SlotVariableReference::~TrackableObjectGraph_TrackableObject_SlotVariableReference() {
708 // @@protoc_insertion_point(destructor:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
709 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
710 (void)arena;
711 return;
712 }
713 SharedDtor();
714 }
715
SharedDtor()716 inline void TrackableObjectGraph_TrackableObject_SlotVariableReference::SharedDtor() {
717 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
718 _impl_.slot_name_.Destroy();
719 }
720
SetCachedSize(int size) const721 void TrackableObjectGraph_TrackableObject_SlotVariableReference::SetCachedSize(int size) const {
722 _impl_._cached_size_.Set(size);
723 }
724
Clear()725 void TrackableObjectGraph_TrackableObject_SlotVariableReference::Clear() {
726 // @@protoc_insertion_point(message_clear_start:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
727 ::uint32_t cached_has_bits = 0;
728 // Prevent compiler warnings about cached_has_bits being unused
729 (void) cached_has_bits;
730
731 _impl_.slot_name_.ClearToEmpty();
732 ::memset(&_impl_.original_variable_node_id_, 0, static_cast<size_t>(
733 reinterpret_cast<char*>(&_impl_.slot_variable_node_id_) -
734 reinterpret_cast<char*>(&_impl_.original_variable_node_id_)) + sizeof(_impl_.slot_variable_node_id_));
735 _internal_metadata_.Clear<std::string>();
736 }
737
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)738 const char* TrackableObjectGraph_TrackableObject_SlotVariableReference::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
739 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
740 while (!ctx->Done(&ptr)) {
741 ::uint32_t tag;
742 ptr = ::_pbi::ReadTag(ptr, &tag);
743 switch (tag >> 3) {
744 // int32 original_variable_node_id = 1;
745 case 1:
746 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
747 _impl_.original_variable_node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
748 CHK_(ptr);
749 } else {
750 goto handle_unusual;
751 }
752 continue;
753 // string slot_name = 2;
754 case 2:
755 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
756 auto str = _internal_mutable_slot_name();
757 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
758 CHK_(ptr);
759 CHK_(::_pbi::VerifyUTF8(str, nullptr));
760 } else {
761 goto handle_unusual;
762 }
763 continue;
764 // int32 slot_variable_node_id = 3;
765 case 3:
766 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
767 _impl_.slot_variable_node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
768 CHK_(ptr);
769 } else {
770 goto handle_unusual;
771 }
772 continue;
773 default:
774 goto handle_unusual;
775 } // switch
776 handle_unusual:
777 if ((tag == 0) || ((tag & 7) == 4)) {
778 CHK_(ptr);
779 ctx->SetLastTag(tag);
780 goto message_done;
781 }
782 ptr = UnknownFieldParse(
783 tag,
784 _internal_metadata_.mutable_unknown_fields<std::string>(),
785 ptr, ctx);
786 CHK_(ptr != nullptr);
787 } // while
788 message_done:
789 return ptr;
790 failure:
791 ptr = nullptr;
792 goto message_done;
793 #undef CHK_
794 }
795
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const796 ::uint8_t* TrackableObjectGraph_TrackableObject_SlotVariableReference::_InternalSerialize(
797 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
798 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
799 ::uint32_t cached_has_bits = 0;
800 (void) cached_has_bits;
801
802 // int32 original_variable_node_id = 1;
803 if (this->_internal_original_variable_node_id() != 0) {
804 target = stream->EnsureSpace(target);
805 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_original_variable_node_id(), target);
806 }
807
808 // string slot_name = 2;
809 if (!this->_internal_slot_name().empty()) {
810 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
811 this->_internal_slot_name().data(), static_cast<int>(this->_internal_slot_name().length()),
812 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
813 "tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference.slot_name");
814 target = stream->WriteStringMaybeAliased(
815 2, this->_internal_slot_name(), target);
816 }
817
818 // int32 slot_variable_node_id = 3;
819 if (this->_internal_slot_variable_node_id() != 0) {
820 target = stream->EnsureSpace(target);
821 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_slot_variable_node_id(), target);
822 }
823
824 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
825 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
826 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
827 }
828 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
829 return target;
830 }
831
ByteSizeLong() const832 size_t TrackableObjectGraph_TrackableObject_SlotVariableReference::ByteSizeLong() const {
833 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
834 size_t total_size = 0;
835
836 ::uint32_t cached_has_bits = 0;
837 // Prevent compiler warnings about cached_has_bits being unused
838 (void) cached_has_bits;
839
840 // string slot_name = 2;
841 if (!this->_internal_slot_name().empty()) {
842 total_size += 1 +
843 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
844 this->_internal_slot_name());
845 }
846
847 // int32 original_variable_node_id = 1;
848 if (this->_internal_original_variable_node_id() != 0) {
849 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_original_variable_node_id());
850 }
851
852 // int32 slot_variable_node_id = 3;
853 if (this->_internal_slot_variable_node_id() != 0) {
854 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_slot_variable_node_id());
855 }
856
857 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
858 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
859 }
860 int cached_size = ::_pbi::ToCachedSize(total_size);
861 SetCachedSize(cached_size);
862 return total_size;
863 }
864
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)865 void TrackableObjectGraph_TrackableObject_SlotVariableReference::CheckTypeAndMergeFrom(
866 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
867 MergeFrom(*::_pbi::DownCast<const TrackableObjectGraph_TrackableObject_SlotVariableReference*>(
868 &from));
869 }
870
MergeFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference & from)871 void TrackableObjectGraph_TrackableObject_SlotVariableReference::MergeFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from) {
872 TrackableObjectGraph_TrackableObject_SlotVariableReference* const _this = this;
873 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
874 GOOGLE_DCHECK_NE(&from, _this);
875 ::uint32_t cached_has_bits = 0;
876 (void) cached_has_bits;
877
878 if (!from._internal_slot_name().empty()) {
879 _this->_internal_set_slot_name(from._internal_slot_name());
880 }
881 if (from._internal_original_variable_node_id() != 0) {
882 _this->_internal_set_original_variable_node_id(from._internal_original_variable_node_id());
883 }
884 if (from._internal_slot_variable_node_id() != 0) {
885 _this->_internal_set_slot_variable_node_id(from._internal_slot_variable_node_id());
886 }
887 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
888 }
889
CopyFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference & from)890 void TrackableObjectGraph_TrackableObject_SlotVariableReference::CopyFrom(const TrackableObjectGraph_TrackableObject_SlotVariableReference& from) {
891 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference)
892 if (&from == this) return;
893 Clear();
894 MergeFrom(from);
895 }
896
IsInitialized() const897 bool TrackableObjectGraph_TrackableObject_SlotVariableReference::IsInitialized() const {
898 return true;
899 }
900
InternalSwap(TrackableObjectGraph_TrackableObject_SlotVariableReference * other)901 void TrackableObjectGraph_TrackableObject_SlotVariableReference::InternalSwap(TrackableObjectGraph_TrackableObject_SlotVariableReference* other) {
902 using std::swap;
903 auto* lhs_arena = GetArenaForAllocation();
904 auto* rhs_arena = other->GetArenaForAllocation();
905 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
906 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
907 &_impl_.slot_name_, lhs_arena,
908 &other->_impl_.slot_name_, rhs_arena
909 );
910 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
911 PROTOBUF_FIELD_OFFSET(TrackableObjectGraph_TrackableObject_SlotVariableReference, _impl_.slot_variable_node_id_)
912 + sizeof(TrackableObjectGraph_TrackableObject_SlotVariableReference::_impl_.slot_variable_node_id_) // NOLINT
913 - PROTOBUF_FIELD_OFFSET(TrackableObjectGraph_TrackableObject_SlotVariableReference, _impl_.original_variable_node_id_)>(
914 reinterpret_cast<char*>(&_impl_.original_variable_node_id_),
915 reinterpret_cast<char*>(&other->_impl_.original_variable_node_id_));
916 }
917
GetTypeName() const918 std::string TrackableObjectGraph_TrackableObject_SlotVariableReference::GetTypeName() const {
919 return "tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference";
920 }
921
922
923 // ===================================================================
924
925 class TrackableObjectGraph_TrackableObject::_Internal {
926 public:
927 static const ::tensorflow::RegisteredSaver& registered_saver(const TrackableObjectGraph_TrackableObject* msg);
928 static const ::PROTOBUF_NAMESPACE_ID::BoolValue& has_checkpoint_values(const TrackableObjectGraph_TrackableObject* msg);
929 };
930
931 const ::tensorflow::RegisteredSaver&
registered_saver(const TrackableObjectGraph_TrackableObject * msg)932 TrackableObjectGraph_TrackableObject::_Internal::registered_saver(const TrackableObjectGraph_TrackableObject* msg) {
933 return *msg->_impl_.registered_saver_;
934 }
935 const ::PROTOBUF_NAMESPACE_ID::BoolValue&
has_checkpoint_values(const TrackableObjectGraph_TrackableObject * msg)936 TrackableObjectGraph_TrackableObject::_Internal::has_checkpoint_values(const TrackableObjectGraph_TrackableObject* msg) {
937 return *msg->_impl_.has_checkpoint_values_;
938 }
clear_has_checkpoint_values()939 void TrackableObjectGraph_TrackableObject::clear_has_checkpoint_values() {
940 if (GetArenaForAllocation() == nullptr && _impl_.has_checkpoint_values_ != nullptr) {
941 delete _impl_.has_checkpoint_values_;
942 }
943 _impl_.has_checkpoint_values_ = nullptr;
944 }
TrackableObjectGraph_TrackableObject(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)945 TrackableObjectGraph_TrackableObject::TrackableObjectGraph_TrackableObject(::PROTOBUF_NAMESPACE_ID::Arena* arena,
946 bool is_message_owned)
947 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
948 SharedCtor(arena, is_message_owned);
949 // @@protoc_insertion_point(arena_constructor:tensorflow.TrackableObjectGraph.TrackableObject)
950 }
TrackableObjectGraph_TrackableObject(const TrackableObjectGraph_TrackableObject & from)951 TrackableObjectGraph_TrackableObject::TrackableObjectGraph_TrackableObject(const TrackableObjectGraph_TrackableObject& from)
952 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
953 TrackableObjectGraph_TrackableObject* const _this = this; (void)_this;
954 new (&_impl_) Impl_{
955 decltype(_impl_.children_){from._impl_.children_}
956 , decltype(_impl_.attributes_){from._impl_.attributes_}
957 , decltype(_impl_.slot_variables_){from._impl_.slot_variables_}
958 , decltype(_impl_.registered_saver_){nullptr}
959 , decltype(_impl_.has_checkpoint_values_){nullptr}
960 , /*decltype(_impl_._cached_size_)*/{}};
961
962 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
963 if (from._internal_has_registered_saver()) {
964 _this->_impl_.registered_saver_ = new ::tensorflow::RegisteredSaver(*from._impl_.registered_saver_);
965 }
966 if (from._internal_has_has_checkpoint_values()) {
967 _this->_impl_.has_checkpoint_values_ = new ::PROTOBUF_NAMESPACE_ID::BoolValue(*from._impl_.has_checkpoint_values_);
968 }
969 // @@protoc_insertion_point(copy_constructor:tensorflow.TrackableObjectGraph.TrackableObject)
970 }
971
SharedCtor(::_pb::Arena * arena,bool is_message_owned)972 inline void TrackableObjectGraph_TrackableObject::SharedCtor(
973 ::_pb::Arena* arena, bool is_message_owned) {
974 (void)arena;
975 (void)is_message_owned;
976 new (&_impl_) Impl_{
977 decltype(_impl_.children_){arena}
978 , decltype(_impl_.attributes_){arena}
979 , decltype(_impl_.slot_variables_){arena}
980 , decltype(_impl_.registered_saver_){nullptr}
981 , decltype(_impl_.has_checkpoint_values_){nullptr}
982 , /*decltype(_impl_._cached_size_)*/{}
983 };
984 }
985
~TrackableObjectGraph_TrackableObject()986 TrackableObjectGraph_TrackableObject::~TrackableObjectGraph_TrackableObject() {
987 // @@protoc_insertion_point(destructor:tensorflow.TrackableObjectGraph.TrackableObject)
988 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
989 (void)arena;
990 return;
991 }
992 SharedDtor();
993 }
994
SharedDtor()995 inline void TrackableObjectGraph_TrackableObject::SharedDtor() {
996 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
997 _impl_.children_.~RepeatedPtrField();
998 _impl_.attributes_.~RepeatedPtrField();
999 _impl_.slot_variables_.~RepeatedPtrField();
1000 if (this != internal_default_instance()) delete _impl_.registered_saver_;
1001 if (this != internal_default_instance()) delete _impl_.has_checkpoint_values_;
1002 }
1003
SetCachedSize(int size) const1004 void TrackableObjectGraph_TrackableObject::SetCachedSize(int size) const {
1005 _impl_._cached_size_.Set(size);
1006 }
1007
Clear()1008 void TrackableObjectGraph_TrackableObject::Clear() {
1009 // @@protoc_insertion_point(message_clear_start:tensorflow.TrackableObjectGraph.TrackableObject)
1010 ::uint32_t cached_has_bits = 0;
1011 // Prevent compiler warnings about cached_has_bits being unused
1012 (void) cached_has_bits;
1013
1014 _impl_.children_.Clear();
1015 _impl_.attributes_.Clear();
1016 _impl_.slot_variables_.Clear();
1017 if (GetArenaForAllocation() == nullptr && _impl_.registered_saver_ != nullptr) {
1018 delete _impl_.registered_saver_;
1019 }
1020 _impl_.registered_saver_ = nullptr;
1021 if (GetArenaForAllocation() == nullptr && _impl_.has_checkpoint_values_ != nullptr) {
1022 delete _impl_.has_checkpoint_values_;
1023 }
1024 _impl_.has_checkpoint_values_ = nullptr;
1025 _internal_metadata_.Clear<std::string>();
1026 }
1027
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1028 const char* TrackableObjectGraph_TrackableObject::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1029 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1030 while (!ctx->Done(&ptr)) {
1031 ::uint32_t tag;
1032 ptr = ::_pbi::ReadTag(ptr, &tag);
1033 switch (tag >> 3) {
1034 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
1035 case 1:
1036 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1037 ptr -= 1;
1038 do {
1039 ptr += 1;
1040 ptr = ctx->ParseMessage(_internal_add_children(), ptr);
1041 CHK_(ptr);
1042 if (!ctx->DataAvailable(ptr)) break;
1043 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1044 } else {
1045 goto handle_unusual;
1046 }
1047 continue;
1048 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor attributes = 2;
1049 case 2:
1050 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1051 ptr -= 1;
1052 do {
1053 ptr += 1;
1054 ptr = ctx->ParseMessage(_internal_add_attributes(), ptr);
1055 CHK_(ptr);
1056 if (!ctx->DataAvailable(ptr)) break;
1057 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1058 } else {
1059 goto handle_unusual;
1060 }
1061 continue;
1062 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
1063 case 3:
1064 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1065 ptr -= 1;
1066 do {
1067 ptr += 1;
1068 ptr = ctx->ParseMessage(_internal_add_slot_variables(), ptr);
1069 CHK_(ptr);
1070 if (!ctx->DataAvailable(ptr)) break;
1071 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1072 } else {
1073 goto handle_unusual;
1074 }
1075 continue;
1076 // .tensorflow.RegisteredSaver registered_saver = 4;
1077 case 4:
1078 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1079 ptr = ctx->ParseMessage(_internal_mutable_registered_saver(), ptr);
1080 CHK_(ptr);
1081 } else {
1082 goto handle_unusual;
1083 }
1084 continue;
1085 // .google.protobuf.BoolValue has_checkpoint_values = 5;
1086 case 5:
1087 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1088 ptr = ctx->ParseMessage(_internal_mutable_has_checkpoint_values(), ptr);
1089 CHK_(ptr);
1090 } else {
1091 goto handle_unusual;
1092 }
1093 continue;
1094 default:
1095 goto handle_unusual;
1096 } // switch
1097 handle_unusual:
1098 if ((tag == 0) || ((tag & 7) == 4)) {
1099 CHK_(ptr);
1100 ctx->SetLastTag(tag);
1101 goto message_done;
1102 }
1103 ptr = UnknownFieldParse(
1104 tag,
1105 _internal_metadata_.mutable_unknown_fields<std::string>(),
1106 ptr, ctx);
1107 CHK_(ptr != nullptr);
1108 } // while
1109 message_done:
1110 return ptr;
1111 failure:
1112 ptr = nullptr;
1113 goto message_done;
1114 #undef CHK_
1115 }
1116
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1117 ::uint8_t* TrackableObjectGraph_TrackableObject::_InternalSerialize(
1118 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1119 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TrackableObjectGraph.TrackableObject)
1120 ::uint32_t cached_has_bits = 0;
1121 (void) cached_has_bits;
1122
1123 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
1124 for (unsigned i = 0,
1125 n = static_cast<unsigned>(this->_internal_children_size()); i < n; i++) {
1126 const auto& repfield = this->_internal_children(i);
1127 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1128 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1129 }
1130
1131 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor attributes = 2;
1132 for (unsigned i = 0,
1133 n = static_cast<unsigned>(this->_internal_attributes_size()); i < n; i++) {
1134 const auto& repfield = this->_internal_attributes(i);
1135 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1136 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1137 }
1138
1139 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
1140 for (unsigned i = 0,
1141 n = static_cast<unsigned>(this->_internal_slot_variables_size()); i < n; i++) {
1142 const auto& repfield = this->_internal_slot_variables(i);
1143 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1144 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
1145 }
1146
1147 // .tensorflow.RegisteredSaver registered_saver = 4;
1148 if (this->_internal_has_registered_saver()) {
1149 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1150 InternalWriteMessage(4, _Internal::registered_saver(this),
1151 _Internal::registered_saver(this).GetCachedSize(), target, stream);
1152 }
1153
1154 // .google.protobuf.BoolValue has_checkpoint_values = 5;
1155 if (this->_internal_has_has_checkpoint_values()) {
1156 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1157 InternalWriteMessage(5, _Internal::has_checkpoint_values(this),
1158 _Internal::has_checkpoint_values(this).GetCachedSize(), target, stream);
1159 }
1160
1161 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1162 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1163 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1164 }
1165 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TrackableObjectGraph.TrackableObject)
1166 return target;
1167 }
1168
ByteSizeLong() const1169 size_t TrackableObjectGraph_TrackableObject::ByteSizeLong() const {
1170 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TrackableObjectGraph.TrackableObject)
1171 size_t total_size = 0;
1172
1173 ::uint32_t cached_has_bits = 0;
1174 // Prevent compiler warnings about cached_has_bits being unused
1175 (void) cached_has_bits;
1176
1177 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
1178 total_size += 1UL * this->_internal_children_size();
1179 for (const auto& msg : this->_impl_.children_) {
1180 total_size +=
1181 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1182 }
1183
1184 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SerializedTensor attributes = 2;
1185 total_size += 1UL * this->_internal_attributes_size();
1186 for (const auto& msg : this->_impl_.attributes_) {
1187 total_size +=
1188 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1189 }
1190
1191 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
1192 total_size += 1UL * this->_internal_slot_variables_size();
1193 for (const auto& msg : this->_impl_.slot_variables_) {
1194 total_size +=
1195 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1196 }
1197
1198 // .tensorflow.RegisteredSaver registered_saver = 4;
1199 if (this->_internal_has_registered_saver()) {
1200 total_size += 1 +
1201 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1202 *_impl_.registered_saver_);
1203 }
1204
1205 // .google.protobuf.BoolValue has_checkpoint_values = 5;
1206 if (this->_internal_has_has_checkpoint_values()) {
1207 total_size += 1 +
1208 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1209 *_impl_.has_checkpoint_values_);
1210 }
1211
1212 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1213 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1214 }
1215 int cached_size = ::_pbi::ToCachedSize(total_size);
1216 SetCachedSize(cached_size);
1217 return total_size;
1218 }
1219
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1220 void TrackableObjectGraph_TrackableObject::CheckTypeAndMergeFrom(
1221 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1222 MergeFrom(*::_pbi::DownCast<const TrackableObjectGraph_TrackableObject*>(
1223 &from));
1224 }
1225
MergeFrom(const TrackableObjectGraph_TrackableObject & from)1226 void TrackableObjectGraph_TrackableObject::MergeFrom(const TrackableObjectGraph_TrackableObject& from) {
1227 TrackableObjectGraph_TrackableObject* const _this = this;
1228 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TrackableObjectGraph.TrackableObject)
1229 GOOGLE_DCHECK_NE(&from, _this);
1230 ::uint32_t cached_has_bits = 0;
1231 (void) cached_has_bits;
1232
1233 _this->_impl_.children_.MergeFrom(from._impl_.children_);
1234 _this->_impl_.attributes_.MergeFrom(from._impl_.attributes_);
1235 _this->_impl_.slot_variables_.MergeFrom(from._impl_.slot_variables_);
1236 if (from._internal_has_registered_saver()) {
1237 _this->_internal_mutable_registered_saver()->::tensorflow::RegisteredSaver::MergeFrom(
1238 from._internal_registered_saver());
1239 }
1240 if (from._internal_has_has_checkpoint_values()) {
1241 _this->_internal_mutable_has_checkpoint_values()->::PROTOBUF_NAMESPACE_ID::BoolValue::MergeFrom(
1242 from._internal_has_checkpoint_values());
1243 }
1244 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1245 }
1246
CopyFrom(const TrackableObjectGraph_TrackableObject & from)1247 void TrackableObjectGraph_TrackableObject::CopyFrom(const TrackableObjectGraph_TrackableObject& from) {
1248 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TrackableObjectGraph.TrackableObject)
1249 if (&from == this) return;
1250 Clear();
1251 MergeFrom(from);
1252 }
1253
IsInitialized() const1254 bool TrackableObjectGraph_TrackableObject::IsInitialized() const {
1255 return true;
1256 }
1257
InternalSwap(TrackableObjectGraph_TrackableObject * other)1258 void TrackableObjectGraph_TrackableObject::InternalSwap(TrackableObjectGraph_TrackableObject* other) {
1259 using std::swap;
1260 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1261 _impl_.children_.InternalSwap(&other->_impl_.children_);
1262 _impl_.attributes_.InternalSwap(&other->_impl_.attributes_);
1263 _impl_.slot_variables_.InternalSwap(&other->_impl_.slot_variables_);
1264 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1265 PROTOBUF_FIELD_OFFSET(TrackableObjectGraph_TrackableObject, _impl_.has_checkpoint_values_)
1266 + sizeof(TrackableObjectGraph_TrackableObject::_impl_.has_checkpoint_values_) // NOLINT
1267 - PROTOBUF_FIELD_OFFSET(TrackableObjectGraph_TrackableObject, _impl_.registered_saver_)>(
1268 reinterpret_cast<char*>(&_impl_.registered_saver_),
1269 reinterpret_cast<char*>(&other->_impl_.registered_saver_));
1270 }
1271
GetTypeName() const1272 std::string TrackableObjectGraph_TrackableObject::GetTypeName() const {
1273 return "tensorflow.TrackableObjectGraph.TrackableObject";
1274 }
1275
1276
1277 // ===================================================================
1278
1279 class TrackableObjectGraph::_Internal {
1280 public:
1281 };
1282
TrackableObjectGraph(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1283 TrackableObjectGraph::TrackableObjectGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1284 bool is_message_owned)
1285 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1286 SharedCtor(arena, is_message_owned);
1287 // @@protoc_insertion_point(arena_constructor:tensorflow.TrackableObjectGraph)
1288 }
TrackableObjectGraph(const TrackableObjectGraph & from)1289 TrackableObjectGraph::TrackableObjectGraph(const TrackableObjectGraph& from)
1290 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1291 TrackableObjectGraph* const _this = this; (void)_this;
1292 new (&_impl_) Impl_{
1293 decltype(_impl_.nodes_){from._impl_.nodes_}
1294 , /*decltype(_impl_._cached_size_)*/{}};
1295
1296 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1297 // @@protoc_insertion_point(copy_constructor:tensorflow.TrackableObjectGraph)
1298 }
1299
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1300 inline void TrackableObjectGraph::SharedCtor(
1301 ::_pb::Arena* arena, bool is_message_owned) {
1302 (void)arena;
1303 (void)is_message_owned;
1304 new (&_impl_) Impl_{
1305 decltype(_impl_.nodes_){arena}
1306 , /*decltype(_impl_._cached_size_)*/{}
1307 };
1308 }
1309
~TrackableObjectGraph()1310 TrackableObjectGraph::~TrackableObjectGraph() {
1311 // @@protoc_insertion_point(destructor:tensorflow.TrackableObjectGraph)
1312 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1313 (void)arena;
1314 return;
1315 }
1316 SharedDtor();
1317 }
1318
SharedDtor()1319 inline void TrackableObjectGraph::SharedDtor() {
1320 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1321 _impl_.nodes_.~RepeatedPtrField();
1322 }
1323
SetCachedSize(int size) const1324 void TrackableObjectGraph::SetCachedSize(int size) const {
1325 _impl_._cached_size_.Set(size);
1326 }
1327
Clear()1328 void TrackableObjectGraph::Clear() {
1329 // @@protoc_insertion_point(message_clear_start:tensorflow.TrackableObjectGraph)
1330 ::uint32_t cached_has_bits = 0;
1331 // Prevent compiler warnings about cached_has_bits being unused
1332 (void) cached_has_bits;
1333
1334 _impl_.nodes_.Clear();
1335 _internal_metadata_.Clear<std::string>();
1336 }
1337
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1338 const char* TrackableObjectGraph::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1339 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1340 while (!ctx->Done(&ptr)) {
1341 ::uint32_t tag;
1342 ptr = ::_pbi::ReadTag(ptr, &tag);
1343 switch (tag >> 3) {
1344 // repeated .tensorflow.TrackableObjectGraph.TrackableObject nodes = 1;
1345 case 1:
1346 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1347 ptr -= 1;
1348 do {
1349 ptr += 1;
1350 ptr = ctx->ParseMessage(_internal_add_nodes(), ptr);
1351 CHK_(ptr);
1352 if (!ctx->DataAvailable(ptr)) break;
1353 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1354 } else {
1355 goto handle_unusual;
1356 }
1357 continue;
1358 default:
1359 goto handle_unusual;
1360 } // switch
1361 handle_unusual:
1362 if ((tag == 0) || ((tag & 7) == 4)) {
1363 CHK_(ptr);
1364 ctx->SetLastTag(tag);
1365 goto message_done;
1366 }
1367 ptr = UnknownFieldParse(
1368 tag,
1369 _internal_metadata_.mutable_unknown_fields<std::string>(),
1370 ptr, ctx);
1371 CHK_(ptr != nullptr);
1372 } // while
1373 message_done:
1374 return ptr;
1375 failure:
1376 ptr = nullptr;
1377 goto message_done;
1378 #undef CHK_
1379 }
1380
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1381 ::uint8_t* TrackableObjectGraph::_InternalSerialize(
1382 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1383 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.TrackableObjectGraph)
1384 ::uint32_t cached_has_bits = 0;
1385 (void) cached_has_bits;
1386
1387 // repeated .tensorflow.TrackableObjectGraph.TrackableObject nodes = 1;
1388 for (unsigned i = 0,
1389 n = static_cast<unsigned>(this->_internal_nodes_size()); i < n; i++) {
1390 const auto& repfield = this->_internal_nodes(i);
1391 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1392 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1393 }
1394
1395 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1396 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1397 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1398 }
1399 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.TrackableObjectGraph)
1400 return target;
1401 }
1402
ByteSizeLong() const1403 size_t TrackableObjectGraph::ByteSizeLong() const {
1404 // @@protoc_insertion_point(message_byte_size_start:tensorflow.TrackableObjectGraph)
1405 size_t total_size = 0;
1406
1407 ::uint32_t cached_has_bits = 0;
1408 // Prevent compiler warnings about cached_has_bits being unused
1409 (void) cached_has_bits;
1410
1411 // repeated .tensorflow.TrackableObjectGraph.TrackableObject nodes = 1;
1412 total_size += 1UL * this->_internal_nodes_size();
1413 for (const auto& msg : this->_impl_.nodes_) {
1414 total_size +=
1415 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1416 }
1417
1418 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1419 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1420 }
1421 int cached_size = ::_pbi::ToCachedSize(total_size);
1422 SetCachedSize(cached_size);
1423 return total_size;
1424 }
1425
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1426 void TrackableObjectGraph::CheckTypeAndMergeFrom(
1427 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1428 MergeFrom(*::_pbi::DownCast<const TrackableObjectGraph*>(
1429 &from));
1430 }
1431
MergeFrom(const TrackableObjectGraph & from)1432 void TrackableObjectGraph::MergeFrom(const TrackableObjectGraph& from) {
1433 TrackableObjectGraph* const _this = this;
1434 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.TrackableObjectGraph)
1435 GOOGLE_DCHECK_NE(&from, _this);
1436 ::uint32_t cached_has_bits = 0;
1437 (void) cached_has_bits;
1438
1439 _this->_impl_.nodes_.MergeFrom(from._impl_.nodes_);
1440 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1441 }
1442
CopyFrom(const TrackableObjectGraph & from)1443 void TrackableObjectGraph::CopyFrom(const TrackableObjectGraph& from) {
1444 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.TrackableObjectGraph)
1445 if (&from == this) return;
1446 Clear();
1447 MergeFrom(from);
1448 }
1449
IsInitialized() const1450 bool TrackableObjectGraph::IsInitialized() const {
1451 return true;
1452 }
1453
InternalSwap(TrackableObjectGraph * other)1454 void TrackableObjectGraph::InternalSwap(TrackableObjectGraph* other) {
1455 using std::swap;
1456 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1457 _impl_.nodes_.InternalSwap(&other->_impl_.nodes_);
1458 }
1459
GetTypeName() const1460 std::string TrackableObjectGraph::GetTypeName() const {
1461 return "tensorflow.TrackableObjectGraph";
1462 }
1463
1464
1465 // ===================================================================
1466
1467 class RegisteredSaver::_Internal {
1468 public:
1469 };
1470
RegisteredSaver(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1471 RegisteredSaver::RegisteredSaver(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1472 bool is_message_owned)
1473 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1474 SharedCtor(arena, is_message_owned);
1475 // @@protoc_insertion_point(arena_constructor:tensorflow.RegisteredSaver)
1476 }
RegisteredSaver(const RegisteredSaver & from)1477 RegisteredSaver::RegisteredSaver(const RegisteredSaver& from)
1478 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1479 RegisteredSaver* const _this = this; (void)_this;
1480 new (&_impl_) Impl_{
1481 decltype(_impl_.name_){}
1482 , decltype(_impl_.object_name_){}
1483 , /*decltype(_impl_._cached_size_)*/{}};
1484
1485 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1486 _impl_.name_.InitDefault();
1487 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1488 _impl_.name_.Set("", GetArenaForAllocation());
1489 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1490 if (!from._internal_name().empty()) {
1491 _this->_impl_.name_.Set(from._internal_name(),
1492 _this->GetArenaForAllocation());
1493 }
1494 _impl_.object_name_.InitDefault();
1495 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1496 _impl_.object_name_.Set("", GetArenaForAllocation());
1497 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1498 if (!from._internal_object_name().empty()) {
1499 _this->_impl_.object_name_.Set(from._internal_object_name(),
1500 _this->GetArenaForAllocation());
1501 }
1502 // @@protoc_insertion_point(copy_constructor:tensorflow.RegisteredSaver)
1503 }
1504
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1505 inline void RegisteredSaver::SharedCtor(
1506 ::_pb::Arena* arena, bool is_message_owned) {
1507 (void)arena;
1508 (void)is_message_owned;
1509 new (&_impl_) Impl_{
1510 decltype(_impl_.name_){}
1511 , decltype(_impl_.object_name_){}
1512 , /*decltype(_impl_._cached_size_)*/{}
1513 };
1514 _impl_.name_.InitDefault();
1515 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1516 _impl_.name_.Set("", GetArenaForAllocation());
1517 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1518 _impl_.object_name_.InitDefault();
1519 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1520 _impl_.object_name_.Set("", GetArenaForAllocation());
1521 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1522 }
1523
~RegisteredSaver()1524 RegisteredSaver::~RegisteredSaver() {
1525 // @@protoc_insertion_point(destructor:tensorflow.RegisteredSaver)
1526 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1527 (void)arena;
1528 return;
1529 }
1530 SharedDtor();
1531 }
1532
SharedDtor()1533 inline void RegisteredSaver::SharedDtor() {
1534 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1535 _impl_.name_.Destroy();
1536 _impl_.object_name_.Destroy();
1537 }
1538
SetCachedSize(int size) const1539 void RegisteredSaver::SetCachedSize(int size) const {
1540 _impl_._cached_size_.Set(size);
1541 }
1542
Clear()1543 void RegisteredSaver::Clear() {
1544 // @@protoc_insertion_point(message_clear_start:tensorflow.RegisteredSaver)
1545 ::uint32_t cached_has_bits = 0;
1546 // Prevent compiler warnings about cached_has_bits being unused
1547 (void) cached_has_bits;
1548
1549 _impl_.name_.ClearToEmpty();
1550 _impl_.object_name_.ClearToEmpty();
1551 _internal_metadata_.Clear<std::string>();
1552 }
1553
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1554 const char* RegisteredSaver::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1555 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1556 while (!ctx->Done(&ptr)) {
1557 ::uint32_t tag;
1558 ptr = ::_pbi::ReadTag(ptr, &tag);
1559 switch (tag >> 3) {
1560 // string name = 1;
1561 case 1:
1562 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1563 auto str = _internal_mutable_name();
1564 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1565 CHK_(ptr);
1566 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1567 } else {
1568 goto handle_unusual;
1569 }
1570 continue;
1571 // string object_name = 2;
1572 case 2:
1573 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1574 auto str = _internal_mutable_object_name();
1575 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1576 CHK_(ptr);
1577 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1578 } else {
1579 goto handle_unusual;
1580 }
1581 continue;
1582 default:
1583 goto handle_unusual;
1584 } // switch
1585 handle_unusual:
1586 if ((tag == 0) || ((tag & 7) == 4)) {
1587 CHK_(ptr);
1588 ctx->SetLastTag(tag);
1589 goto message_done;
1590 }
1591 ptr = UnknownFieldParse(
1592 tag,
1593 _internal_metadata_.mutable_unknown_fields<std::string>(),
1594 ptr, ctx);
1595 CHK_(ptr != nullptr);
1596 } // while
1597 message_done:
1598 return ptr;
1599 failure:
1600 ptr = nullptr;
1601 goto message_done;
1602 #undef CHK_
1603 }
1604
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1605 ::uint8_t* RegisteredSaver::_InternalSerialize(
1606 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1607 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.RegisteredSaver)
1608 ::uint32_t cached_has_bits = 0;
1609 (void) cached_has_bits;
1610
1611 // string name = 1;
1612 if (!this->_internal_name().empty()) {
1613 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1614 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
1615 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1616 "tensorflow.RegisteredSaver.name");
1617 target = stream->WriteStringMaybeAliased(
1618 1, this->_internal_name(), target);
1619 }
1620
1621 // string object_name = 2;
1622 if (!this->_internal_object_name().empty()) {
1623 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1624 this->_internal_object_name().data(), static_cast<int>(this->_internal_object_name().length()),
1625 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1626 "tensorflow.RegisteredSaver.object_name");
1627 target = stream->WriteStringMaybeAliased(
1628 2, this->_internal_object_name(), target);
1629 }
1630
1631 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1632 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1633 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1634 }
1635 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.RegisteredSaver)
1636 return target;
1637 }
1638
ByteSizeLong() const1639 size_t RegisteredSaver::ByteSizeLong() const {
1640 // @@protoc_insertion_point(message_byte_size_start:tensorflow.RegisteredSaver)
1641 size_t total_size = 0;
1642
1643 ::uint32_t cached_has_bits = 0;
1644 // Prevent compiler warnings about cached_has_bits being unused
1645 (void) cached_has_bits;
1646
1647 // string name = 1;
1648 if (!this->_internal_name().empty()) {
1649 total_size += 1 +
1650 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1651 this->_internal_name());
1652 }
1653
1654 // string object_name = 2;
1655 if (!this->_internal_object_name().empty()) {
1656 total_size += 1 +
1657 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1658 this->_internal_object_name());
1659 }
1660
1661 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1662 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1663 }
1664 int cached_size = ::_pbi::ToCachedSize(total_size);
1665 SetCachedSize(cached_size);
1666 return total_size;
1667 }
1668
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1669 void RegisteredSaver::CheckTypeAndMergeFrom(
1670 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1671 MergeFrom(*::_pbi::DownCast<const RegisteredSaver*>(
1672 &from));
1673 }
1674
MergeFrom(const RegisteredSaver & from)1675 void RegisteredSaver::MergeFrom(const RegisteredSaver& from) {
1676 RegisteredSaver* const _this = this;
1677 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.RegisteredSaver)
1678 GOOGLE_DCHECK_NE(&from, _this);
1679 ::uint32_t cached_has_bits = 0;
1680 (void) cached_has_bits;
1681
1682 if (!from._internal_name().empty()) {
1683 _this->_internal_set_name(from._internal_name());
1684 }
1685 if (!from._internal_object_name().empty()) {
1686 _this->_internal_set_object_name(from._internal_object_name());
1687 }
1688 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1689 }
1690
CopyFrom(const RegisteredSaver & from)1691 void RegisteredSaver::CopyFrom(const RegisteredSaver& from) {
1692 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.RegisteredSaver)
1693 if (&from == this) return;
1694 Clear();
1695 MergeFrom(from);
1696 }
1697
IsInitialized() const1698 bool RegisteredSaver::IsInitialized() const {
1699 return true;
1700 }
1701
InternalSwap(RegisteredSaver * other)1702 void RegisteredSaver::InternalSwap(RegisteredSaver* other) {
1703 using std::swap;
1704 auto* lhs_arena = GetArenaForAllocation();
1705 auto* rhs_arena = other->GetArenaForAllocation();
1706 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1707 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1708 &_impl_.name_, lhs_arena,
1709 &other->_impl_.name_, rhs_arena
1710 );
1711 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1712 &_impl_.object_name_, lhs_arena,
1713 &other->_impl_.object_name_, rhs_arena
1714 );
1715 }
1716
GetTypeName() const1717 std::string RegisteredSaver::GetTypeName() const {
1718 return "tensorflow.RegisteredSaver";
1719 }
1720
1721
1722 // @@protoc_insertion_point(namespace_scope)
1723 } // namespace tensorflow
1724 PROTOBUF_NAMESPACE_OPEN
1725 template<> PROTOBUF_NOINLINE ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference*
CreateMaybeMessage(Arena * arena)1726 Arena::CreateMaybeMessage< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >(Arena* arena) {
1727 return Arena::CreateMessageInternal< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >(arena);
1728 }
1729 template<> PROTOBUF_NOINLINE ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor*
CreateMaybeMessage(Arena * arena)1730 Arena::CreateMaybeMessage< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >(Arena* arena) {
1731 return Arena::CreateMessageInternal< ::tensorflow::TrackableObjectGraph_TrackableObject_SerializedTensor >(arena);
1732 }
1733 template<> PROTOBUF_NOINLINE ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference*
CreateMaybeMessage(Arena * arena)1734 Arena::CreateMaybeMessage< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >(Arena* arena) {
1735 return Arena::CreateMessageInternal< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >(arena);
1736 }
1737 template<> PROTOBUF_NOINLINE ::tensorflow::TrackableObjectGraph_TrackableObject*
CreateMaybeMessage(Arena * arena)1738 Arena::CreateMaybeMessage< ::tensorflow::TrackableObjectGraph_TrackableObject >(Arena* arena) {
1739 return Arena::CreateMessageInternal< ::tensorflow::TrackableObjectGraph_TrackableObject >(arena);
1740 }
1741 template<> PROTOBUF_NOINLINE ::tensorflow::TrackableObjectGraph*
CreateMaybeMessage(Arena * arena)1742 Arena::CreateMaybeMessage< ::tensorflow::TrackableObjectGraph >(Arena* arena) {
1743 return Arena::CreateMessageInternal< ::tensorflow::TrackableObjectGraph >(arena);
1744 }
1745 template<> PROTOBUF_NOINLINE ::tensorflow::RegisteredSaver*
CreateMaybeMessage(Arena * arena)1746 Arena::CreateMaybeMessage< ::tensorflow::RegisteredSaver >(Arena* arena) {
1747 return Arena::CreateMessageInternal< ::tensorflow::RegisteredSaver >(arena);
1748 }
1749 PROTOBUF_NAMESPACE_CLOSE
1750
1751 // @@protoc_insertion_point(global_scope)
1752 #include <google/protobuf/port_undef.inc>
1753