1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/protobuf/saver.proto
3 
4 #include "tensorflow/core/protobuf/saver.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 {
SaverDef(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR SaverDef::SaverDef(
23     ::_pbi::ConstantInitialized): _impl_{
24     /*decltype(_impl_.filename_tensor_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
25   , /*decltype(_impl_.save_tensor_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
26   , /*decltype(_impl_.restore_op_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
27   , /*decltype(_impl_.max_to_keep_)*/0
28   , /*decltype(_impl_.sharded_)*/false
29   , /*decltype(_impl_.keep_checkpoint_every_n_hours_)*/0
30   , /*decltype(_impl_.version_)*/0
31   , /*decltype(_impl_._cached_size_)*/{}} {}
32 struct SaverDefDefaultTypeInternal {
SaverDefDefaultTypeInternaltensorflow::SaverDefDefaultTypeInternal33   PROTOBUF_CONSTEXPR SaverDefDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~SaverDefDefaultTypeInternaltensorflow::SaverDefDefaultTypeInternal35   ~SaverDefDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     SaverDef _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaverDefDefaultTypeInternal _SaverDef_default_instance_;
41 }  // namespace tensorflow
42 namespace tensorflow {
SaverDef_CheckpointFormatVersion_IsValid(int value)43 bool SaverDef_CheckpointFormatVersion_IsValid(int value) {
44   switch (value) {
45     case 0:
46     case 1:
47     case 2:
48       return true;
49     default:
50       return false;
51   }
52 }
53 
54 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> SaverDef_CheckpointFormatVersion_strings[3] = {};
55 
56 static const char SaverDef_CheckpointFormatVersion_names[] =
57   "LEGACY"
58   "V1"
59   "V2";
60 
61 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SaverDef_CheckpointFormatVersion_entries[] = {
62   { {SaverDef_CheckpointFormatVersion_names + 0, 6}, 0 },
63   { {SaverDef_CheckpointFormatVersion_names + 6, 2}, 1 },
64   { {SaverDef_CheckpointFormatVersion_names + 8, 2}, 2 },
65 };
66 
67 static const int SaverDef_CheckpointFormatVersion_entries_by_number[] = {
68   0, // 0 -> LEGACY
69   1, // 1 -> V1
70   2, // 2 -> V2
71 };
72 
SaverDef_CheckpointFormatVersion_Name(SaverDef_CheckpointFormatVersion value)73 const std::string& SaverDef_CheckpointFormatVersion_Name(
74     SaverDef_CheckpointFormatVersion value) {
75   static const bool dummy =
76       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
77           SaverDef_CheckpointFormatVersion_entries,
78           SaverDef_CheckpointFormatVersion_entries_by_number,
79           3, SaverDef_CheckpointFormatVersion_strings);
80   (void) dummy;
81   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
82       SaverDef_CheckpointFormatVersion_entries,
83       SaverDef_CheckpointFormatVersion_entries_by_number,
84       3, value);
85   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
86                      SaverDef_CheckpointFormatVersion_strings[idx].get();
87 }
SaverDef_CheckpointFormatVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,SaverDef_CheckpointFormatVersion * value)88 bool SaverDef_CheckpointFormatVersion_Parse(
89     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SaverDef_CheckpointFormatVersion* value) {
90   int int_value;
91   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
92       SaverDef_CheckpointFormatVersion_entries, 3, name, &int_value);
93   if (success) {
94     *value = static_cast<SaverDef_CheckpointFormatVersion>(int_value);
95   }
96   return success;
97 }
98 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
99 constexpr SaverDef_CheckpointFormatVersion SaverDef::LEGACY;
100 constexpr SaverDef_CheckpointFormatVersion SaverDef::V1;
101 constexpr SaverDef_CheckpointFormatVersion SaverDef::V2;
102 constexpr SaverDef_CheckpointFormatVersion SaverDef::CheckpointFormatVersion_MIN;
103 constexpr SaverDef_CheckpointFormatVersion SaverDef::CheckpointFormatVersion_MAX;
104 constexpr int SaverDef::CheckpointFormatVersion_ARRAYSIZE;
105 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
106 
107 // ===================================================================
108 
109 class SaverDef::_Internal {
110  public:
111 };
112 
SaverDef(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)113 SaverDef::SaverDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
114                          bool is_message_owned)
115   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
116   SharedCtor(arena, is_message_owned);
117   // @@protoc_insertion_point(arena_constructor:tensorflow.SaverDef)
118 }
SaverDef(const SaverDef & from)119 SaverDef::SaverDef(const SaverDef& from)
120   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
121   SaverDef* const _this = this; (void)_this;
122   new (&_impl_) Impl_{
123       decltype(_impl_.filename_tensor_name_){}
124     , decltype(_impl_.save_tensor_name_){}
125     , decltype(_impl_.restore_op_name_){}
126     , decltype(_impl_.max_to_keep_){}
127     , decltype(_impl_.sharded_){}
128     , decltype(_impl_.keep_checkpoint_every_n_hours_){}
129     , decltype(_impl_.version_){}
130     , /*decltype(_impl_._cached_size_)*/{}};
131 
132   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
133   _impl_.filename_tensor_name_.InitDefault();
134   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
135     _impl_.filename_tensor_name_.Set("", GetArenaForAllocation());
136   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
137   if (!from._internal_filename_tensor_name().empty()) {
138     _this->_impl_.filename_tensor_name_.Set(from._internal_filename_tensor_name(),
139       _this->GetArenaForAllocation());
140   }
141   _impl_.save_tensor_name_.InitDefault();
142   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
143     _impl_.save_tensor_name_.Set("", GetArenaForAllocation());
144   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
145   if (!from._internal_save_tensor_name().empty()) {
146     _this->_impl_.save_tensor_name_.Set(from._internal_save_tensor_name(),
147       _this->GetArenaForAllocation());
148   }
149   _impl_.restore_op_name_.InitDefault();
150   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
151     _impl_.restore_op_name_.Set("", GetArenaForAllocation());
152   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
153   if (!from._internal_restore_op_name().empty()) {
154     _this->_impl_.restore_op_name_.Set(from._internal_restore_op_name(),
155       _this->GetArenaForAllocation());
156   }
157   ::memcpy(&_impl_.max_to_keep_, &from._impl_.max_to_keep_,
158     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.version_) -
159     reinterpret_cast<char*>(&_impl_.max_to_keep_)) + sizeof(_impl_.version_));
160   // @@protoc_insertion_point(copy_constructor:tensorflow.SaverDef)
161 }
162 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)163 inline void SaverDef::SharedCtor(
164     ::_pb::Arena* arena, bool is_message_owned) {
165   (void)arena;
166   (void)is_message_owned;
167   new (&_impl_) Impl_{
168       decltype(_impl_.filename_tensor_name_){}
169     , decltype(_impl_.save_tensor_name_){}
170     , decltype(_impl_.restore_op_name_){}
171     , decltype(_impl_.max_to_keep_){0}
172     , decltype(_impl_.sharded_){false}
173     , decltype(_impl_.keep_checkpoint_every_n_hours_){0}
174     , decltype(_impl_.version_){0}
175     , /*decltype(_impl_._cached_size_)*/{}
176   };
177   _impl_.filename_tensor_name_.InitDefault();
178   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
179     _impl_.filename_tensor_name_.Set("", GetArenaForAllocation());
180   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
181   _impl_.save_tensor_name_.InitDefault();
182   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
183     _impl_.save_tensor_name_.Set("", GetArenaForAllocation());
184   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
185   _impl_.restore_op_name_.InitDefault();
186   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
187     _impl_.restore_op_name_.Set("", GetArenaForAllocation());
188   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
189 }
190 
~SaverDef()191 SaverDef::~SaverDef() {
192   // @@protoc_insertion_point(destructor:tensorflow.SaverDef)
193   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
194   (void)arena;
195     return;
196   }
197   SharedDtor();
198 }
199 
SharedDtor()200 inline void SaverDef::SharedDtor() {
201   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
202   _impl_.filename_tensor_name_.Destroy();
203   _impl_.save_tensor_name_.Destroy();
204   _impl_.restore_op_name_.Destroy();
205 }
206 
SetCachedSize(int size) const207 void SaverDef::SetCachedSize(int size) const {
208   _impl_._cached_size_.Set(size);
209 }
210 
Clear()211 void SaverDef::Clear() {
212 // @@protoc_insertion_point(message_clear_start:tensorflow.SaverDef)
213   ::uint32_t cached_has_bits = 0;
214   // Prevent compiler warnings about cached_has_bits being unused
215   (void) cached_has_bits;
216 
217   _impl_.filename_tensor_name_.ClearToEmpty();
218   _impl_.save_tensor_name_.ClearToEmpty();
219   _impl_.restore_op_name_.ClearToEmpty();
220   ::memset(&_impl_.max_to_keep_, 0, static_cast<size_t>(
221       reinterpret_cast<char*>(&_impl_.version_) -
222       reinterpret_cast<char*>(&_impl_.max_to_keep_)) + sizeof(_impl_.version_));
223   _internal_metadata_.Clear<std::string>();
224 }
225 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)226 const char* SaverDef::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
227 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
228   while (!ctx->Done(&ptr)) {
229     ::uint32_t tag;
230     ptr = ::_pbi::ReadTag(ptr, &tag);
231     switch (tag >> 3) {
232       // string filename_tensor_name = 1;
233       case 1:
234         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
235           auto str = _internal_mutable_filename_tensor_name();
236           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
237           CHK_(ptr);
238           CHK_(::_pbi::VerifyUTF8(str, nullptr));
239         } else {
240           goto handle_unusual;
241         }
242         continue;
243       // string save_tensor_name = 2;
244       case 2:
245         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
246           auto str = _internal_mutable_save_tensor_name();
247           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
248           CHK_(ptr);
249           CHK_(::_pbi::VerifyUTF8(str, nullptr));
250         } else {
251           goto handle_unusual;
252         }
253         continue;
254       // string restore_op_name = 3;
255       case 3:
256         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
257           auto str = _internal_mutable_restore_op_name();
258           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
259           CHK_(ptr);
260           CHK_(::_pbi::VerifyUTF8(str, nullptr));
261         } else {
262           goto handle_unusual;
263         }
264         continue;
265       // int32 max_to_keep = 4;
266       case 4:
267         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
268           _impl_.max_to_keep_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
269           CHK_(ptr);
270         } else {
271           goto handle_unusual;
272         }
273         continue;
274       // bool sharded = 5;
275       case 5:
276         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
277           _impl_.sharded_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
278           CHK_(ptr);
279         } else {
280           goto handle_unusual;
281         }
282         continue;
283       // float keep_checkpoint_every_n_hours = 6;
284       case 6:
285         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 53)) {
286           _impl_.keep_checkpoint_every_n_hours_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
287           ptr += sizeof(float);
288         } else {
289           goto handle_unusual;
290         }
291         continue;
292       // .tensorflow.SaverDef.CheckpointFormatVersion version = 7;
293       case 7:
294         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
295           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
296           CHK_(ptr);
297           _internal_set_version(static_cast<::tensorflow::SaverDef_CheckpointFormatVersion>(val));
298         } else {
299           goto handle_unusual;
300         }
301         continue;
302       default:
303         goto handle_unusual;
304     }  // switch
305   handle_unusual:
306     if ((tag == 0) || ((tag & 7) == 4)) {
307       CHK_(ptr);
308       ctx->SetLastTag(tag);
309       goto message_done;
310     }
311     ptr = UnknownFieldParse(
312         tag,
313         _internal_metadata_.mutable_unknown_fields<std::string>(),
314         ptr, ctx);
315     CHK_(ptr != nullptr);
316   }  // while
317 message_done:
318   return ptr;
319 failure:
320   ptr = nullptr;
321   goto message_done;
322 #undef CHK_
323 }
324 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const325 ::uint8_t* SaverDef::_InternalSerialize(
326     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
327   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SaverDef)
328   ::uint32_t cached_has_bits = 0;
329   (void) cached_has_bits;
330 
331   // string filename_tensor_name = 1;
332   if (!this->_internal_filename_tensor_name().empty()) {
333     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
334       this->_internal_filename_tensor_name().data(), static_cast<int>(this->_internal_filename_tensor_name().length()),
335       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
336       "tensorflow.SaverDef.filename_tensor_name");
337     target = stream->WriteStringMaybeAliased(
338         1, this->_internal_filename_tensor_name(), target);
339   }
340 
341   // string save_tensor_name = 2;
342   if (!this->_internal_save_tensor_name().empty()) {
343     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
344       this->_internal_save_tensor_name().data(), static_cast<int>(this->_internal_save_tensor_name().length()),
345       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
346       "tensorflow.SaverDef.save_tensor_name");
347     target = stream->WriteStringMaybeAliased(
348         2, this->_internal_save_tensor_name(), target);
349   }
350 
351   // string restore_op_name = 3;
352   if (!this->_internal_restore_op_name().empty()) {
353     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
354       this->_internal_restore_op_name().data(), static_cast<int>(this->_internal_restore_op_name().length()),
355       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
356       "tensorflow.SaverDef.restore_op_name");
357     target = stream->WriteStringMaybeAliased(
358         3, this->_internal_restore_op_name(), target);
359   }
360 
361   // int32 max_to_keep = 4;
362   if (this->_internal_max_to_keep() != 0) {
363     target = stream->EnsureSpace(target);
364     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_max_to_keep(), target);
365   }
366 
367   // bool sharded = 5;
368   if (this->_internal_sharded() != 0) {
369     target = stream->EnsureSpace(target);
370     target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_sharded(), target);
371   }
372 
373   // float keep_checkpoint_every_n_hours = 6;
374   static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
375   float tmp_keep_checkpoint_every_n_hours = this->_internal_keep_checkpoint_every_n_hours();
376   ::uint32_t raw_keep_checkpoint_every_n_hours;
377   memcpy(&raw_keep_checkpoint_every_n_hours, &tmp_keep_checkpoint_every_n_hours, sizeof(tmp_keep_checkpoint_every_n_hours));
378   if (raw_keep_checkpoint_every_n_hours != 0) {
379     target = stream->EnsureSpace(target);
380     target = ::_pbi::WireFormatLite::WriteFloatToArray(6, this->_internal_keep_checkpoint_every_n_hours(), target);
381   }
382 
383   // .tensorflow.SaverDef.CheckpointFormatVersion version = 7;
384   if (this->_internal_version() != 0) {
385     target = stream->EnsureSpace(target);
386     target = ::_pbi::WireFormatLite::WriteEnumToArray(
387       7, this->_internal_version(), target);
388   }
389 
390   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
391     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
392         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
393   }
394   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SaverDef)
395   return target;
396 }
397 
ByteSizeLong() const398 size_t SaverDef::ByteSizeLong() const {
399 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SaverDef)
400   size_t total_size = 0;
401 
402   ::uint32_t cached_has_bits = 0;
403   // Prevent compiler warnings about cached_has_bits being unused
404   (void) cached_has_bits;
405 
406   // string filename_tensor_name = 1;
407   if (!this->_internal_filename_tensor_name().empty()) {
408     total_size += 1 +
409       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
410         this->_internal_filename_tensor_name());
411   }
412 
413   // string save_tensor_name = 2;
414   if (!this->_internal_save_tensor_name().empty()) {
415     total_size += 1 +
416       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
417         this->_internal_save_tensor_name());
418   }
419 
420   // string restore_op_name = 3;
421   if (!this->_internal_restore_op_name().empty()) {
422     total_size += 1 +
423       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
424         this->_internal_restore_op_name());
425   }
426 
427   // int32 max_to_keep = 4;
428   if (this->_internal_max_to_keep() != 0) {
429     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_max_to_keep());
430   }
431 
432   // bool sharded = 5;
433   if (this->_internal_sharded() != 0) {
434     total_size += 1 + 1;
435   }
436 
437   // float keep_checkpoint_every_n_hours = 6;
438   static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
439   float tmp_keep_checkpoint_every_n_hours = this->_internal_keep_checkpoint_every_n_hours();
440   ::uint32_t raw_keep_checkpoint_every_n_hours;
441   memcpy(&raw_keep_checkpoint_every_n_hours, &tmp_keep_checkpoint_every_n_hours, sizeof(tmp_keep_checkpoint_every_n_hours));
442   if (raw_keep_checkpoint_every_n_hours != 0) {
443     total_size += 1 + 4;
444   }
445 
446   // .tensorflow.SaverDef.CheckpointFormatVersion version = 7;
447   if (this->_internal_version() != 0) {
448     total_size += 1 +
449       ::_pbi::WireFormatLite::EnumSize(this->_internal_version());
450   }
451 
452   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
453     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
454   }
455   int cached_size = ::_pbi::ToCachedSize(total_size);
456   SetCachedSize(cached_size);
457   return total_size;
458 }
459 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)460 void SaverDef::CheckTypeAndMergeFrom(
461     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
462   MergeFrom(*::_pbi::DownCast<const SaverDef*>(
463       &from));
464 }
465 
MergeFrom(const SaverDef & from)466 void SaverDef::MergeFrom(const SaverDef& from) {
467   SaverDef* const _this = this;
468   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SaverDef)
469   GOOGLE_DCHECK_NE(&from, _this);
470   ::uint32_t cached_has_bits = 0;
471   (void) cached_has_bits;
472 
473   if (!from._internal_filename_tensor_name().empty()) {
474     _this->_internal_set_filename_tensor_name(from._internal_filename_tensor_name());
475   }
476   if (!from._internal_save_tensor_name().empty()) {
477     _this->_internal_set_save_tensor_name(from._internal_save_tensor_name());
478   }
479   if (!from._internal_restore_op_name().empty()) {
480     _this->_internal_set_restore_op_name(from._internal_restore_op_name());
481   }
482   if (from._internal_max_to_keep() != 0) {
483     _this->_internal_set_max_to_keep(from._internal_max_to_keep());
484   }
485   if (from._internal_sharded() != 0) {
486     _this->_internal_set_sharded(from._internal_sharded());
487   }
488   static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
489   float tmp_keep_checkpoint_every_n_hours = from._internal_keep_checkpoint_every_n_hours();
490   ::uint32_t raw_keep_checkpoint_every_n_hours;
491   memcpy(&raw_keep_checkpoint_every_n_hours, &tmp_keep_checkpoint_every_n_hours, sizeof(tmp_keep_checkpoint_every_n_hours));
492   if (raw_keep_checkpoint_every_n_hours != 0) {
493     _this->_internal_set_keep_checkpoint_every_n_hours(from._internal_keep_checkpoint_every_n_hours());
494   }
495   if (from._internal_version() != 0) {
496     _this->_internal_set_version(from._internal_version());
497   }
498   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
499 }
500 
CopyFrom(const SaverDef & from)501 void SaverDef::CopyFrom(const SaverDef& from) {
502 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SaverDef)
503   if (&from == this) return;
504   Clear();
505   MergeFrom(from);
506 }
507 
IsInitialized() const508 bool SaverDef::IsInitialized() const {
509   return true;
510 }
511 
InternalSwap(SaverDef * other)512 void SaverDef::InternalSwap(SaverDef* other) {
513   using std::swap;
514   auto* lhs_arena = GetArenaForAllocation();
515   auto* rhs_arena = other->GetArenaForAllocation();
516   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
517   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
518       &_impl_.filename_tensor_name_, lhs_arena,
519       &other->_impl_.filename_tensor_name_, rhs_arena
520   );
521   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
522       &_impl_.save_tensor_name_, lhs_arena,
523       &other->_impl_.save_tensor_name_, rhs_arena
524   );
525   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
526       &_impl_.restore_op_name_, lhs_arena,
527       &other->_impl_.restore_op_name_, rhs_arena
528   );
529   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
530       PROTOBUF_FIELD_OFFSET(SaverDef, _impl_.version_)
531       + sizeof(SaverDef::_impl_.version_)  // NOLINT
532       - PROTOBUF_FIELD_OFFSET(SaverDef, _impl_.max_to_keep_)>(
533           reinterpret_cast<char*>(&_impl_.max_to_keep_),
534           reinterpret_cast<char*>(&other->_impl_.max_to_keep_));
535 }
536 
GetTypeName() const537 std::string SaverDef::GetTypeName() const {
538   return "tensorflow.SaverDef";
539 }
540 
541 
542 // @@protoc_insertion_point(namespace_scope)
543 }  // namespace tensorflow
544 PROTOBUF_NAMESPACE_OPEN
545 template<> PROTOBUF_NOINLINE ::tensorflow::SaverDef*
CreateMaybeMessage(Arena * arena)546 Arena::CreateMaybeMessage< ::tensorflow::SaverDef >(Arena* arena) {
547   return Arena::CreateMessageInternal< ::tensorflow::SaverDef >(arena);
548 }
549 PROTOBUF_NAMESPACE_CLOSE
550 
551 // @@protoc_insertion_point(global_scope)
552 #include <google/protobuf/port_undef.inc>
553