1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/util/saved_tensor_slice.proto
3 
4 #include "tensorflow/core/util/saved_tensor_slice.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 {
SavedSliceMeta(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR SavedSliceMeta::SavedSliceMeta(
23     ::_pbi::ConstantInitialized): _impl_{
24     /*decltype(_impl_.slice_)*/{}
25   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
26   , /*decltype(_impl_.shape_)*/nullptr
27   , /*decltype(_impl_.type_)*/0
28   , /*decltype(_impl_._cached_size_)*/{}} {}
29 struct SavedSliceMetaDefaultTypeInternal {
SavedSliceMetaDefaultTypeInternaltensorflow::SavedSliceMetaDefaultTypeInternal30   PROTOBUF_CONSTEXPR SavedSliceMetaDefaultTypeInternal()
31       : _instance(::_pbi::ConstantInitialized{}) {}
~SavedSliceMetaDefaultTypeInternaltensorflow::SavedSliceMetaDefaultTypeInternal32   ~SavedSliceMetaDefaultTypeInternal() {}
33   union {  // NOLINT(misc-non-private-member-variables-in-classes)
34     SavedSliceMeta _instance;
35   };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SavedSliceMetaDefaultTypeInternal _SavedSliceMeta_default_instance_;
SavedTensorSliceMeta(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR SavedTensorSliceMeta::SavedTensorSliceMeta(
39     ::_pbi::ConstantInitialized): _impl_{
40     /*decltype(_impl_.tensor_)*/{}
41   , /*decltype(_impl_.versions_)*/nullptr
42   , /*decltype(_impl_._cached_size_)*/{}} {}
43 struct SavedTensorSliceMetaDefaultTypeInternal {
SavedTensorSliceMetaDefaultTypeInternaltensorflow::SavedTensorSliceMetaDefaultTypeInternal44   PROTOBUF_CONSTEXPR SavedTensorSliceMetaDefaultTypeInternal()
45       : _instance(::_pbi::ConstantInitialized{}) {}
~SavedTensorSliceMetaDefaultTypeInternaltensorflow::SavedTensorSliceMetaDefaultTypeInternal46   ~SavedTensorSliceMetaDefaultTypeInternal() {}
47   union {  // NOLINT(misc-non-private-member-variables-in-classes)
48     SavedTensorSliceMeta _instance;
49   };
50 };
51 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SavedTensorSliceMetaDefaultTypeInternal _SavedTensorSliceMeta_default_instance_;
SavedSlice(::_pbi::ConstantInitialized)52 PROTOBUF_CONSTEXPR SavedSlice::SavedSlice(
53     ::_pbi::ConstantInitialized): _impl_{
54     /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
55   , /*decltype(_impl_.slice_)*/nullptr
56   , /*decltype(_impl_.data_)*/nullptr
57   , /*decltype(_impl_._cached_size_)*/{}} {}
58 struct SavedSliceDefaultTypeInternal {
SavedSliceDefaultTypeInternaltensorflow::SavedSliceDefaultTypeInternal59   PROTOBUF_CONSTEXPR SavedSliceDefaultTypeInternal()
60       : _instance(::_pbi::ConstantInitialized{}) {}
~SavedSliceDefaultTypeInternaltensorflow::SavedSliceDefaultTypeInternal61   ~SavedSliceDefaultTypeInternal() {}
62   union {  // NOLINT(misc-non-private-member-variables-in-classes)
63     SavedSlice _instance;
64   };
65 };
66 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SavedSliceDefaultTypeInternal _SavedSlice_default_instance_;
SavedTensorSlices(::_pbi::ConstantInitialized)67 PROTOBUF_CONSTEXPR SavedTensorSlices::SavedTensorSlices(
68     ::_pbi::ConstantInitialized): _impl_{
69     /*decltype(_impl_.meta_)*/nullptr
70   , /*decltype(_impl_.data_)*/nullptr
71   , /*decltype(_impl_._cached_size_)*/{}} {}
72 struct SavedTensorSlicesDefaultTypeInternal {
SavedTensorSlicesDefaultTypeInternaltensorflow::SavedTensorSlicesDefaultTypeInternal73   PROTOBUF_CONSTEXPR SavedTensorSlicesDefaultTypeInternal()
74       : _instance(::_pbi::ConstantInitialized{}) {}
~SavedTensorSlicesDefaultTypeInternaltensorflow::SavedTensorSlicesDefaultTypeInternal75   ~SavedTensorSlicesDefaultTypeInternal() {}
76   union {  // NOLINT(misc-non-private-member-variables-in-classes)
77     SavedTensorSlices _instance;
78   };
79 };
80 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SavedTensorSlicesDefaultTypeInternal _SavedTensorSlices_default_instance_;
81 }  // namespace tensorflow
82 namespace tensorflow {
83 
84 // ===================================================================
85 
86 class SavedSliceMeta::_Internal {
87  public:
88   static const ::tensorflow::TensorShapeProto& shape(const SavedSliceMeta* msg);
89 };
90 
91 const ::tensorflow::TensorShapeProto&
shape(const SavedSliceMeta * msg)92 SavedSliceMeta::_Internal::shape(const SavedSliceMeta* msg) {
93   return *msg->_impl_.shape_;
94 }
clear_shape()95 void SavedSliceMeta::clear_shape() {
96   if (GetArenaForAllocation() == nullptr && _impl_.shape_ != nullptr) {
97     delete _impl_.shape_;
98   }
99   _impl_.shape_ = nullptr;
100 }
clear_slice()101 void SavedSliceMeta::clear_slice() {
102   _impl_.slice_.Clear();
103 }
SavedSliceMeta(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)104 SavedSliceMeta::SavedSliceMeta(::PROTOBUF_NAMESPACE_ID::Arena* arena,
105                          bool is_message_owned)
106   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
107   SharedCtor(arena, is_message_owned);
108   // @@protoc_insertion_point(arena_constructor:tensorflow.SavedSliceMeta)
109 }
SavedSliceMeta(const SavedSliceMeta & from)110 SavedSliceMeta::SavedSliceMeta(const SavedSliceMeta& from)
111   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
112   SavedSliceMeta* const _this = this; (void)_this;
113   new (&_impl_) Impl_{
114       decltype(_impl_.slice_){from._impl_.slice_}
115     , decltype(_impl_.name_){}
116     , decltype(_impl_.shape_){nullptr}
117     , decltype(_impl_.type_){}
118     , /*decltype(_impl_._cached_size_)*/{}};
119 
120   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
121   _impl_.name_.InitDefault();
122   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
123     _impl_.name_.Set("", GetArenaForAllocation());
124   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
125   if (!from._internal_name().empty()) {
126     _this->_impl_.name_.Set(from._internal_name(),
127       _this->GetArenaForAllocation());
128   }
129   if (from._internal_has_shape()) {
130     _this->_impl_.shape_ = new ::tensorflow::TensorShapeProto(*from._impl_.shape_);
131   }
132   _this->_impl_.type_ = from._impl_.type_;
133   // @@protoc_insertion_point(copy_constructor:tensorflow.SavedSliceMeta)
134 }
135 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)136 inline void SavedSliceMeta::SharedCtor(
137     ::_pb::Arena* arena, bool is_message_owned) {
138   (void)arena;
139   (void)is_message_owned;
140   new (&_impl_) Impl_{
141       decltype(_impl_.slice_){arena}
142     , decltype(_impl_.name_){}
143     , decltype(_impl_.shape_){nullptr}
144     , decltype(_impl_.type_){0}
145     , /*decltype(_impl_._cached_size_)*/{}
146   };
147   _impl_.name_.InitDefault();
148   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
149     _impl_.name_.Set("", GetArenaForAllocation());
150   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
151 }
152 
~SavedSliceMeta()153 SavedSliceMeta::~SavedSliceMeta() {
154   // @@protoc_insertion_point(destructor:tensorflow.SavedSliceMeta)
155   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
156   (void)arena;
157     return;
158   }
159   SharedDtor();
160 }
161 
SharedDtor()162 inline void SavedSliceMeta::SharedDtor() {
163   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
164   _impl_.slice_.~RepeatedPtrField();
165   _impl_.name_.Destroy();
166   if (this != internal_default_instance()) delete _impl_.shape_;
167 }
168 
SetCachedSize(int size) const169 void SavedSliceMeta::SetCachedSize(int size) const {
170   _impl_._cached_size_.Set(size);
171 }
172 
Clear()173 void SavedSliceMeta::Clear() {
174 // @@protoc_insertion_point(message_clear_start:tensorflow.SavedSliceMeta)
175   ::uint32_t cached_has_bits = 0;
176   // Prevent compiler warnings about cached_has_bits being unused
177   (void) cached_has_bits;
178 
179   _impl_.slice_.Clear();
180   _impl_.name_.ClearToEmpty();
181   if (GetArenaForAllocation() == nullptr && _impl_.shape_ != nullptr) {
182     delete _impl_.shape_;
183   }
184   _impl_.shape_ = nullptr;
185   _impl_.type_ = 0;
186   _internal_metadata_.Clear<std::string>();
187 }
188 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)189 const char* SavedSliceMeta::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
190 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
191   while (!ctx->Done(&ptr)) {
192     ::uint32_t tag;
193     ptr = ::_pbi::ReadTag(ptr, &tag);
194     switch (tag >> 3) {
195       // string name = 1;
196       case 1:
197         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
198           auto str = _internal_mutable_name();
199           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
200           CHK_(ptr);
201           CHK_(::_pbi::VerifyUTF8(str, nullptr));
202         } else {
203           goto handle_unusual;
204         }
205         continue;
206       // .tensorflow.TensorShapeProto shape = 2;
207       case 2:
208         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
209           ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr);
210           CHK_(ptr);
211         } else {
212           goto handle_unusual;
213         }
214         continue;
215       // .tensorflow.DataType type = 3;
216       case 3:
217         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
218           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
219           CHK_(ptr);
220           _internal_set_type(static_cast<::tensorflow::DataType>(val));
221         } else {
222           goto handle_unusual;
223         }
224         continue;
225       // repeated .tensorflow.TensorSliceProto slice = 4;
226       case 4:
227         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
228           ptr -= 1;
229           do {
230             ptr += 1;
231             ptr = ctx->ParseMessage(_internal_add_slice(), ptr);
232             CHK_(ptr);
233             if (!ctx->DataAvailable(ptr)) break;
234           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
235         } else {
236           goto handle_unusual;
237         }
238         continue;
239       default:
240         goto handle_unusual;
241     }  // switch
242   handle_unusual:
243     if ((tag == 0) || ((tag & 7) == 4)) {
244       CHK_(ptr);
245       ctx->SetLastTag(tag);
246       goto message_done;
247     }
248     ptr = UnknownFieldParse(
249         tag,
250         _internal_metadata_.mutable_unknown_fields<std::string>(),
251         ptr, ctx);
252     CHK_(ptr != nullptr);
253   }  // while
254 message_done:
255   return ptr;
256 failure:
257   ptr = nullptr;
258   goto message_done;
259 #undef CHK_
260 }
261 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const262 ::uint8_t* SavedSliceMeta::_InternalSerialize(
263     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
264   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SavedSliceMeta)
265   ::uint32_t cached_has_bits = 0;
266   (void) cached_has_bits;
267 
268   // string name = 1;
269   if (!this->_internal_name().empty()) {
270     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
271       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
272       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
273       "tensorflow.SavedSliceMeta.name");
274     target = stream->WriteStringMaybeAliased(
275         1, this->_internal_name(), target);
276   }
277 
278   // .tensorflow.TensorShapeProto shape = 2;
279   if (this->_internal_has_shape()) {
280     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
281       InternalWriteMessage(2, _Internal::shape(this),
282         _Internal::shape(this).GetCachedSize(), target, stream);
283   }
284 
285   // .tensorflow.DataType type = 3;
286   if (this->_internal_type() != 0) {
287     target = stream->EnsureSpace(target);
288     target = ::_pbi::WireFormatLite::WriteEnumToArray(
289       3, this->_internal_type(), target);
290   }
291 
292   // repeated .tensorflow.TensorSliceProto slice = 4;
293   for (unsigned i = 0,
294       n = static_cast<unsigned>(this->_internal_slice_size()); i < n; i++) {
295     const auto& repfield = this->_internal_slice(i);
296     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
297         InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
298   }
299 
300   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
301     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
302         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
303   }
304   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SavedSliceMeta)
305   return target;
306 }
307 
ByteSizeLong() const308 size_t SavedSliceMeta::ByteSizeLong() const {
309 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SavedSliceMeta)
310   size_t total_size = 0;
311 
312   ::uint32_t cached_has_bits = 0;
313   // Prevent compiler warnings about cached_has_bits being unused
314   (void) cached_has_bits;
315 
316   // repeated .tensorflow.TensorSliceProto slice = 4;
317   total_size += 1UL * this->_internal_slice_size();
318   for (const auto& msg : this->_impl_.slice_) {
319     total_size +=
320       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
321   }
322 
323   // string name = 1;
324   if (!this->_internal_name().empty()) {
325     total_size += 1 +
326       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
327         this->_internal_name());
328   }
329 
330   // .tensorflow.TensorShapeProto shape = 2;
331   if (this->_internal_has_shape()) {
332     total_size += 1 +
333       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
334         *_impl_.shape_);
335   }
336 
337   // .tensorflow.DataType type = 3;
338   if (this->_internal_type() != 0) {
339     total_size += 1 +
340       ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
341   }
342 
343   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
344     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
345   }
346   int cached_size = ::_pbi::ToCachedSize(total_size);
347   SetCachedSize(cached_size);
348   return total_size;
349 }
350 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)351 void SavedSliceMeta::CheckTypeAndMergeFrom(
352     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
353   MergeFrom(*::_pbi::DownCast<const SavedSliceMeta*>(
354       &from));
355 }
356 
MergeFrom(const SavedSliceMeta & from)357 void SavedSliceMeta::MergeFrom(const SavedSliceMeta& from) {
358   SavedSliceMeta* const _this = this;
359   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SavedSliceMeta)
360   GOOGLE_DCHECK_NE(&from, _this);
361   ::uint32_t cached_has_bits = 0;
362   (void) cached_has_bits;
363 
364   _this->_impl_.slice_.MergeFrom(from._impl_.slice_);
365   if (!from._internal_name().empty()) {
366     _this->_internal_set_name(from._internal_name());
367   }
368   if (from._internal_has_shape()) {
369     _this->_internal_mutable_shape()->::tensorflow::TensorShapeProto::MergeFrom(
370         from._internal_shape());
371   }
372   if (from._internal_type() != 0) {
373     _this->_internal_set_type(from._internal_type());
374   }
375   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
376 }
377 
CopyFrom(const SavedSliceMeta & from)378 void SavedSliceMeta::CopyFrom(const SavedSliceMeta& from) {
379 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SavedSliceMeta)
380   if (&from == this) return;
381   Clear();
382   MergeFrom(from);
383 }
384 
IsInitialized() const385 bool SavedSliceMeta::IsInitialized() const {
386   return true;
387 }
388 
InternalSwap(SavedSliceMeta * other)389 void SavedSliceMeta::InternalSwap(SavedSliceMeta* other) {
390   using std::swap;
391   auto* lhs_arena = GetArenaForAllocation();
392   auto* rhs_arena = other->GetArenaForAllocation();
393   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
394   _impl_.slice_.InternalSwap(&other->_impl_.slice_);
395   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
396       &_impl_.name_, lhs_arena,
397       &other->_impl_.name_, rhs_arena
398   );
399   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
400       PROTOBUF_FIELD_OFFSET(SavedSliceMeta, _impl_.type_)
401       + sizeof(SavedSliceMeta::_impl_.type_)  // NOLINT
402       - PROTOBUF_FIELD_OFFSET(SavedSliceMeta, _impl_.shape_)>(
403           reinterpret_cast<char*>(&_impl_.shape_),
404           reinterpret_cast<char*>(&other->_impl_.shape_));
405 }
406 
GetTypeName() const407 std::string SavedSliceMeta::GetTypeName() const {
408   return "tensorflow.SavedSliceMeta";
409 }
410 
411 
412 // ===================================================================
413 
414 class SavedTensorSliceMeta::_Internal {
415  public:
416   static const ::tensorflow::VersionDef& versions(const SavedTensorSliceMeta* msg);
417 };
418 
419 const ::tensorflow::VersionDef&
versions(const SavedTensorSliceMeta * msg)420 SavedTensorSliceMeta::_Internal::versions(const SavedTensorSliceMeta* msg) {
421   return *msg->_impl_.versions_;
422 }
clear_versions()423 void SavedTensorSliceMeta::clear_versions() {
424   if (GetArenaForAllocation() == nullptr && _impl_.versions_ != nullptr) {
425     delete _impl_.versions_;
426   }
427   _impl_.versions_ = nullptr;
428 }
SavedTensorSliceMeta(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)429 SavedTensorSliceMeta::SavedTensorSliceMeta(::PROTOBUF_NAMESPACE_ID::Arena* arena,
430                          bool is_message_owned)
431   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
432   SharedCtor(arena, is_message_owned);
433   // @@protoc_insertion_point(arena_constructor:tensorflow.SavedTensorSliceMeta)
434 }
SavedTensorSliceMeta(const SavedTensorSliceMeta & from)435 SavedTensorSliceMeta::SavedTensorSliceMeta(const SavedTensorSliceMeta& from)
436   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
437   SavedTensorSliceMeta* const _this = this; (void)_this;
438   new (&_impl_) Impl_{
439       decltype(_impl_.tensor_){from._impl_.tensor_}
440     , decltype(_impl_.versions_){nullptr}
441     , /*decltype(_impl_._cached_size_)*/{}};
442 
443   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
444   if (from._internal_has_versions()) {
445     _this->_impl_.versions_ = new ::tensorflow::VersionDef(*from._impl_.versions_);
446   }
447   // @@protoc_insertion_point(copy_constructor:tensorflow.SavedTensorSliceMeta)
448 }
449 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)450 inline void SavedTensorSliceMeta::SharedCtor(
451     ::_pb::Arena* arena, bool is_message_owned) {
452   (void)arena;
453   (void)is_message_owned;
454   new (&_impl_) Impl_{
455       decltype(_impl_.tensor_){arena}
456     , decltype(_impl_.versions_){nullptr}
457     , /*decltype(_impl_._cached_size_)*/{}
458   };
459 }
460 
~SavedTensorSliceMeta()461 SavedTensorSliceMeta::~SavedTensorSliceMeta() {
462   // @@protoc_insertion_point(destructor:tensorflow.SavedTensorSliceMeta)
463   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
464   (void)arena;
465     return;
466   }
467   SharedDtor();
468 }
469 
SharedDtor()470 inline void SavedTensorSliceMeta::SharedDtor() {
471   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
472   _impl_.tensor_.~RepeatedPtrField();
473   if (this != internal_default_instance()) delete _impl_.versions_;
474 }
475 
SetCachedSize(int size) const476 void SavedTensorSliceMeta::SetCachedSize(int size) const {
477   _impl_._cached_size_.Set(size);
478 }
479 
Clear()480 void SavedTensorSliceMeta::Clear() {
481 // @@protoc_insertion_point(message_clear_start:tensorflow.SavedTensorSliceMeta)
482   ::uint32_t cached_has_bits = 0;
483   // Prevent compiler warnings about cached_has_bits being unused
484   (void) cached_has_bits;
485 
486   _impl_.tensor_.Clear();
487   if (GetArenaForAllocation() == nullptr && _impl_.versions_ != nullptr) {
488     delete _impl_.versions_;
489   }
490   _impl_.versions_ = nullptr;
491   _internal_metadata_.Clear<std::string>();
492 }
493 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)494 const char* SavedTensorSliceMeta::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
495 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
496   while (!ctx->Done(&ptr)) {
497     ::uint32_t tag;
498     ptr = ::_pbi::ReadTag(ptr, &tag);
499     switch (tag >> 3) {
500       // repeated .tensorflow.SavedSliceMeta tensor = 1;
501       case 1:
502         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
503           ptr -= 1;
504           do {
505             ptr += 1;
506             ptr = ctx->ParseMessage(_internal_add_tensor(), ptr);
507             CHK_(ptr);
508             if (!ctx->DataAvailable(ptr)) break;
509           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
510         } else {
511           goto handle_unusual;
512         }
513         continue;
514       // .tensorflow.VersionDef versions = 2;
515       case 2:
516         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
517           ptr = ctx->ParseMessage(_internal_mutable_versions(), ptr);
518           CHK_(ptr);
519         } else {
520           goto handle_unusual;
521         }
522         continue;
523       default:
524         goto handle_unusual;
525     }  // switch
526   handle_unusual:
527     if ((tag == 0) || ((tag & 7) == 4)) {
528       CHK_(ptr);
529       ctx->SetLastTag(tag);
530       goto message_done;
531     }
532     ptr = UnknownFieldParse(
533         tag,
534         _internal_metadata_.mutable_unknown_fields<std::string>(),
535         ptr, ctx);
536     CHK_(ptr != nullptr);
537   }  // while
538 message_done:
539   return ptr;
540 failure:
541   ptr = nullptr;
542   goto message_done;
543 #undef CHK_
544 }
545 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const546 ::uint8_t* SavedTensorSliceMeta::_InternalSerialize(
547     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
548   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SavedTensorSliceMeta)
549   ::uint32_t cached_has_bits = 0;
550   (void) cached_has_bits;
551 
552   // repeated .tensorflow.SavedSliceMeta tensor = 1;
553   for (unsigned i = 0,
554       n = static_cast<unsigned>(this->_internal_tensor_size()); i < n; i++) {
555     const auto& repfield = this->_internal_tensor(i);
556     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
557         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
558   }
559 
560   // .tensorflow.VersionDef versions = 2;
561   if (this->_internal_has_versions()) {
562     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
563       InternalWriteMessage(2, _Internal::versions(this),
564         _Internal::versions(this).GetCachedSize(), target, stream);
565   }
566 
567   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
568     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
569         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
570   }
571   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SavedTensorSliceMeta)
572   return target;
573 }
574 
ByteSizeLong() const575 size_t SavedTensorSliceMeta::ByteSizeLong() const {
576 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SavedTensorSliceMeta)
577   size_t total_size = 0;
578 
579   ::uint32_t cached_has_bits = 0;
580   // Prevent compiler warnings about cached_has_bits being unused
581   (void) cached_has_bits;
582 
583   // repeated .tensorflow.SavedSliceMeta tensor = 1;
584   total_size += 1UL * this->_internal_tensor_size();
585   for (const auto& msg : this->_impl_.tensor_) {
586     total_size +=
587       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
588   }
589 
590   // .tensorflow.VersionDef versions = 2;
591   if (this->_internal_has_versions()) {
592     total_size += 1 +
593       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
594         *_impl_.versions_);
595   }
596 
597   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
598     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
599   }
600   int cached_size = ::_pbi::ToCachedSize(total_size);
601   SetCachedSize(cached_size);
602   return total_size;
603 }
604 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)605 void SavedTensorSliceMeta::CheckTypeAndMergeFrom(
606     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
607   MergeFrom(*::_pbi::DownCast<const SavedTensorSliceMeta*>(
608       &from));
609 }
610 
MergeFrom(const SavedTensorSliceMeta & from)611 void SavedTensorSliceMeta::MergeFrom(const SavedTensorSliceMeta& from) {
612   SavedTensorSliceMeta* const _this = this;
613   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SavedTensorSliceMeta)
614   GOOGLE_DCHECK_NE(&from, _this);
615   ::uint32_t cached_has_bits = 0;
616   (void) cached_has_bits;
617 
618   _this->_impl_.tensor_.MergeFrom(from._impl_.tensor_);
619   if (from._internal_has_versions()) {
620     _this->_internal_mutable_versions()->::tensorflow::VersionDef::MergeFrom(
621         from._internal_versions());
622   }
623   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
624 }
625 
CopyFrom(const SavedTensorSliceMeta & from)626 void SavedTensorSliceMeta::CopyFrom(const SavedTensorSliceMeta& from) {
627 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SavedTensorSliceMeta)
628   if (&from == this) return;
629   Clear();
630   MergeFrom(from);
631 }
632 
IsInitialized() const633 bool SavedTensorSliceMeta::IsInitialized() const {
634   return true;
635 }
636 
InternalSwap(SavedTensorSliceMeta * other)637 void SavedTensorSliceMeta::InternalSwap(SavedTensorSliceMeta* other) {
638   using std::swap;
639   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
640   _impl_.tensor_.InternalSwap(&other->_impl_.tensor_);
641   swap(_impl_.versions_, other->_impl_.versions_);
642 }
643 
GetTypeName() const644 std::string SavedTensorSliceMeta::GetTypeName() const {
645   return "tensorflow.SavedTensorSliceMeta";
646 }
647 
648 
649 // ===================================================================
650 
651 class SavedSlice::_Internal {
652  public:
653   static const ::tensorflow::TensorSliceProto& slice(const SavedSlice* msg);
654   static const ::tensorflow::TensorProto& data(const SavedSlice* msg);
655 };
656 
657 const ::tensorflow::TensorSliceProto&
slice(const SavedSlice * msg)658 SavedSlice::_Internal::slice(const SavedSlice* msg) {
659   return *msg->_impl_.slice_;
660 }
661 const ::tensorflow::TensorProto&
data(const SavedSlice * msg)662 SavedSlice::_Internal::data(const SavedSlice* msg) {
663   return *msg->_impl_.data_;
664 }
clear_slice()665 void SavedSlice::clear_slice() {
666   if (GetArenaForAllocation() == nullptr && _impl_.slice_ != nullptr) {
667     delete _impl_.slice_;
668   }
669   _impl_.slice_ = nullptr;
670 }
clear_data()671 void SavedSlice::clear_data() {
672   if (GetArenaForAllocation() == nullptr && _impl_.data_ != nullptr) {
673     delete _impl_.data_;
674   }
675   _impl_.data_ = nullptr;
676 }
SavedSlice(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)677 SavedSlice::SavedSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
678                          bool is_message_owned)
679   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
680   SharedCtor(arena, is_message_owned);
681   // @@protoc_insertion_point(arena_constructor:tensorflow.SavedSlice)
682 }
SavedSlice(const SavedSlice & from)683 SavedSlice::SavedSlice(const SavedSlice& from)
684   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
685   SavedSlice* const _this = this; (void)_this;
686   new (&_impl_) Impl_{
687       decltype(_impl_.name_){}
688     , decltype(_impl_.slice_){nullptr}
689     , decltype(_impl_.data_){nullptr}
690     , /*decltype(_impl_._cached_size_)*/{}};
691 
692   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
693   _impl_.name_.InitDefault();
694   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
695     _impl_.name_.Set("", GetArenaForAllocation());
696   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
697   if (!from._internal_name().empty()) {
698     _this->_impl_.name_.Set(from._internal_name(),
699       _this->GetArenaForAllocation());
700   }
701   if (from._internal_has_slice()) {
702     _this->_impl_.slice_ = new ::tensorflow::TensorSliceProto(*from._impl_.slice_);
703   }
704   if (from._internal_has_data()) {
705     _this->_impl_.data_ = new ::tensorflow::TensorProto(*from._impl_.data_);
706   }
707   // @@protoc_insertion_point(copy_constructor:tensorflow.SavedSlice)
708 }
709 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)710 inline void SavedSlice::SharedCtor(
711     ::_pb::Arena* arena, bool is_message_owned) {
712   (void)arena;
713   (void)is_message_owned;
714   new (&_impl_) Impl_{
715       decltype(_impl_.name_){}
716     , decltype(_impl_.slice_){nullptr}
717     , decltype(_impl_.data_){nullptr}
718     , /*decltype(_impl_._cached_size_)*/{}
719   };
720   _impl_.name_.InitDefault();
721   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
722     _impl_.name_.Set("", GetArenaForAllocation());
723   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
724 }
725 
~SavedSlice()726 SavedSlice::~SavedSlice() {
727   // @@protoc_insertion_point(destructor:tensorflow.SavedSlice)
728   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
729   (void)arena;
730     return;
731   }
732   SharedDtor();
733 }
734 
SharedDtor()735 inline void SavedSlice::SharedDtor() {
736   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
737   _impl_.name_.Destroy();
738   if (this != internal_default_instance()) delete _impl_.slice_;
739   if (this != internal_default_instance()) delete _impl_.data_;
740 }
741 
SetCachedSize(int size) const742 void SavedSlice::SetCachedSize(int size) const {
743   _impl_._cached_size_.Set(size);
744 }
745 
Clear()746 void SavedSlice::Clear() {
747 // @@protoc_insertion_point(message_clear_start:tensorflow.SavedSlice)
748   ::uint32_t cached_has_bits = 0;
749   // Prevent compiler warnings about cached_has_bits being unused
750   (void) cached_has_bits;
751 
752   _impl_.name_.ClearToEmpty();
753   if (GetArenaForAllocation() == nullptr && _impl_.slice_ != nullptr) {
754     delete _impl_.slice_;
755   }
756   _impl_.slice_ = nullptr;
757   if (GetArenaForAllocation() == nullptr && _impl_.data_ != nullptr) {
758     delete _impl_.data_;
759   }
760   _impl_.data_ = nullptr;
761   _internal_metadata_.Clear<std::string>();
762 }
763 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)764 const char* SavedSlice::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
765 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
766   while (!ctx->Done(&ptr)) {
767     ::uint32_t tag;
768     ptr = ::_pbi::ReadTag(ptr, &tag);
769     switch (tag >> 3) {
770       // string name = 1;
771       case 1:
772         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
773           auto str = _internal_mutable_name();
774           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
775           CHK_(ptr);
776           CHK_(::_pbi::VerifyUTF8(str, nullptr));
777         } else {
778           goto handle_unusual;
779         }
780         continue;
781       // .tensorflow.TensorSliceProto slice = 2;
782       case 2:
783         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
784           ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr);
785           CHK_(ptr);
786         } else {
787           goto handle_unusual;
788         }
789         continue;
790       // .tensorflow.TensorProto data = 3;
791       case 3:
792         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
793           ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
794           CHK_(ptr);
795         } else {
796           goto handle_unusual;
797         }
798         continue;
799       default:
800         goto handle_unusual;
801     }  // switch
802   handle_unusual:
803     if ((tag == 0) || ((tag & 7) == 4)) {
804       CHK_(ptr);
805       ctx->SetLastTag(tag);
806       goto message_done;
807     }
808     ptr = UnknownFieldParse(
809         tag,
810         _internal_metadata_.mutable_unknown_fields<std::string>(),
811         ptr, ctx);
812     CHK_(ptr != nullptr);
813   }  // while
814 message_done:
815   return ptr;
816 failure:
817   ptr = nullptr;
818   goto message_done;
819 #undef CHK_
820 }
821 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const822 ::uint8_t* SavedSlice::_InternalSerialize(
823     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
824   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SavedSlice)
825   ::uint32_t cached_has_bits = 0;
826   (void) cached_has_bits;
827 
828   // string name = 1;
829   if (!this->_internal_name().empty()) {
830     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
831       this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
832       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
833       "tensorflow.SavedSlice.name");
834     target = stream->WriteStringMaybeAliased(
835         1, this->_internal_name(), target);
836   }
837 
838   // .tensorflow.TensorSliceProto slice = 2;
839   if (this->_internal_has_slice()) {
840     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
841       InternalWriteMessage(2, _Internal::slice(this),
842         _Internal::slice(this).GetCachedSize(), target, stream);
843   }
844 
845   // .tensorflow.TensorProto data = 3;
846   if (this->_internal_has_data()) {
847     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
848       InternalWriteMessage(3, _Internal::data(this),
849         _Internal::data(this).GetCachedSize(), target, stream);
850   }
851 
852   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
853     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
854         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
855   }
856   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SavedSlice)
857   return target;
858 }
859 
ByteSizeLong() const860 size_t SavedSlice::ByteSizeLong() const {
861 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SavedSlice)
862   size_t total_size = 0;
863 
864   ::uint32_t cached_has_bits = 0;
865   // Prevent compiler warnings about cached_has_bits being unused
866   (void) cached_has_bits;
867 
868   // string name = 1;
869   if (!this->_internal_name().empty()) {
870     total_size += 1 +
871       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
872         this->_internal_name());
873   }
874 
875   // .tensorflow.TensorSliceProto slice = 2;
876   if (this->_internal_has_slice()) {
877     total_size += 1 +
878       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
879         *_impl_.slice_);
880   }
881 
882   // .tensorflow.TensorProto data = 3;
883   if (this->_internal_has_data()) {
884     total_size += 1 +
885       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
886         *_impl_.data_);
887   }
888 
889   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
890     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
891   }
892   int cached_size = ::_pbi::ToCachedSize(total_size);
893   SetCachedSize(cached_size);
894   return total_size;
895 }
896 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)897 void SavedSlice::CheckTypeAndMergeFrom(
898     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
899   MergeFrom(*::_pbi::DownCast<const SavedSlice*>(
900       &from));
901 }
902 
MergeFrom(const SavedSlice & from)903 void SavedSlice::MergeFrom(const SavedSlice& from) {
904   SavedSlice* const _this = this;
905   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SavedSlice)
906   GOOGLE_DCHECK_NE(&from, _this);
907   ::uint32_t cached_has_bits = 0;
908   (void) cached_has_bits;
909 
910   if (!from._internal_name().empty()) {
911     _this->_internal_set_name(from._internal_name());
912   }
913   if (from._internal_has_slice()) {
914     _this->_internal_mutable_slice()->::tensorflow::TensorSliceProto::MergeFrom(
915         from._internal_slice());
916   }
917   if (from._internal_has_data()) {
918     _this->_internal_mutable_data()->::tensorflow::TensorProto::MergeFrom(
919         from._internal_data());
920   }
921   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
922 }
923 
CopyFrom(const SavedSlice & from)924 void SavedSlice::CopyFrom(const SavedSlice& from) {
925 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SavedSlice)
926   if (&from == this) return;
927   Clear();
928   MergeFrom(from);
929 }
930 
IsInitialized() const931 bool SavedSlice::IsInitialized() const {
932   return true;
933 }
934 
InternalSwap(SavedSlice * other)935 void SavedSlice::InternalSwap(SavedSlice* other) {
936   using std::swap;
937   auto* lhs_arena = GetArenaForAllocation();
938   auto* rhs_arena = other->GetArenaForAllocation();
939   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
940   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
941       &_impl_.name_, lhs_arena,
942       &other->_impl_.name_, rhs_arena
943   );
944   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
945       PROTOBUF_FIELD_OFFSET(SavedSlice, _impl_.data_)
946       + sizeof(SavedSlice::_impl_.data_)  // NOLINT
947       - PROTOBUF_FIELD_OFFSET(SavedSlice, _impl_.slice_)>(
948           reinterpret_cast<char*>(&_impl_.slice_),
949           reinterpret_cast<char*>(&other->_impl_.slice_));
950 }
951 
GetTypeName() const952 std::string SavedSlice::GetTypeName() const {
953   return "tensorflow.SavedSlice";
954 }
955 
956 
957 // ===================================================================
958 
959 class SavedTensorSlices::_Internal {
960  public:
961   static const ::tensorflow::SavedTensorSliceMeta& meta(const SavedTensorSlices* msg);
962   static const ::tensorflow::SavedSlice& data(const SavedTensorSlices* msg);
963 };
964 
965 const ::tensorflow::SavedTensorSliceMeta&
meta(const SavedTensorSlices * msg)966 SavedTensorSlices::_Internal::meta(const SavedTensorSlices* msg) {
967   return *msg->_impl_.meta_;
968 }
969 const ::tensorflow::SavedSlice&
data(const SavedTensorSlices * msg)970 SavedTensorSlices::_Internal::data(const SavedTensorSlices* msg) {
971   return *msg->_impl_.data_;
972 }
SavedTensorSlices(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)973 SavedTensorSlices::SavedTensorSlices(::PROTOBUF_NAMESPACE_ID::Arena* arena,
974                          bool is_message_owned)
975   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
976   SharedCtor(arena, is_message_owned);
977   // @@protoc_insertion_point(arena_constructor:tensorflow.SavedTensorSlices)
978 }
SavedTensorSlices(const SavedTensorSlices & from)979 SavedTensorSlices::SavedTensorSlices(const SavedTensorSlices& from)
980   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
981   SavedTensorSlices* const _this = this; (void)_this;
982   new (&_impl_) Impl_{
983       decltype(_impl_.meta_){nullptr}
984     , decltype(_impl_.data_){nullptr}
985     , /*decltype(_impl_._cached_size_)*/{}};
986 
987   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
988   if (from._internal_has_meta()) {
989     _this->_impl_.meta_ = new ::tensorflow::SavedTensorSliceMeta(*from._impl_.meta_);
990   }
991   if (from._internal_has_data()) {
992     _this->_impl_.data_ = new ::tensorflow::SavedSlice(*from._impl_.data_);
993   }
994   // @@protoc_insertion_point(copy_constructor:tensorflow.SavedTensorSlices)
995 }
996 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)997 inline void SavedTensorSlices::SharedCtor(
998     ::_pb::Arena* arena, bool is_message_owned) {
999   (void)arena;
1000   (void)is_message_owned;
1001   new (&_impl_) Impl_{
1002       decltype(_impl_.meta_){nullptr}
1003     , decltype(_impl_.data_){nullptr}
1004     , /*decltype(_impl_._cached_size_)*/{}
1005   };
1006 }
1007 
~SavedTensorSlices()1008 SavedTensorSlices::~SavedTensorSlices() {
1009   // @@protoc_insertion_point(destructor:tensorflow.SavedTensorSlices)
1010   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1011   (void)arena;
1012     return;
1013   }
1014   SharedDtor();
1015 }
1016 
SharedDtor()1017 inline void SavedTensorSlices::SharedDtor() {
1018   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1019   if (this != internal_default_instance()) delete _impl_.meta_;
1020   if (this != internal_default_instance()) delete _impl_.data_;
1021 }
1022 
SetCachedSize(int size) const1023 void SavedTensorSlices::SetCachedSize(int size) const {
1024   _impl_._cached_size_.Set(size);
1025 }
1026 
Clear()1027 void SavedTensorSlices::Clear() {
1028 // @@protoc_insertion_point(message_clear_start:tensorflow.SavedTensorSlices)
1029   ::uint32_t cached_has_bits = 0;
1030   // Prevent compiler warnings about cached_has_bits being unused
1031   (void) cached_has_bits;
1032 
1033   if (GetArenaForAllocation() == nullptr && _impl_.meta_ != nullptr) {
1034     delete _impl_.meta_;
1035   }
1036   _impl_.meta_ = nullptr;
1037   if (GetArenaForAllocation() == nullptr && _impl_.data_ != nullptr) {
1038     delete _impl_.data_;
1039   }
1040   _impl_.data_ = nullptr;
1041   _internal_metadata_.Clear<std::string>();
1042 }
1043 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1044 const char* SavedTensorSlices::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1045 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1046   while (!ctx->Done(&ptr)) {
1047     ::uint32_t tag;
1048     ptr = ::_pbi::ReadTag(ptr, &tag);
1049     switch (tag >> 3) {
1050       // .tensorflow.SavedTensorSliceMeta meta = 1;
1051       case 1:
1052         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1053           ptr = ctx->ParseMessage(_internal_mutable_meta(), ptr);
1054           CHK_(ptr);
1055         } else {
1056           goto handle_unusual;
1057         }
1058         continue;
1059       // .tensorflow.SavedSlice data = 2;
1060       case 2:
1061         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1062           ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
1063           CHK_(ptr);
1064         } else {
1065           goto handle_unusual;
1066         }
1067         continue;
1068       default:
1069         goto handle_unusual;
1070     }  // switch
1071   handle_unusual:
1072     if ((tag == 0) || ((tag & 7) == 4)) {
1073       CHK_(ptr);
1074       ctx->SetLastTag(tag);
1075       goto message_done;
1076     }
1077     ptr = UnknownFieldParse(
1078         tag,
1079         _internal_metadata_.mutable_unknown_fields<std::string>(),
1080         ptr, ctx);
1081     CHK_(ptr != nullptr);
1082   }  // while
1083 message_done:
1084   return ptr;
1085 failure:
1086   ptr = nullptr;
1087   goto message_done;
1088 #undef CHK_
1089 }
1090 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1091 ::uint8_t* SavedTensorSlices::_InternalSerialize(
1092     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1093   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.SavedTensorSlices)
1094   ::uint32_t cached_has_bits = 0;
1095   (void) cached_has_bits;
1096 
1097   // .tensorflow.SavedTensorSliceMeta meta = 1;
1098   if (this->_internal_has_meta()) {
1099     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1100       InternalWriteMessage(1, _Internal::meta(this),
1101         _Internal::meta(this).GetCachedSize(), target, stream);
1102   }
1103 
1104   // .tensorflow.SavedSlice data = 2;
1105   if (this->_internal_has_data()) {
1106     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1107       InternalWriteMessage(2, _Internal::data(this),
1108         _Internal::data(this).GetCachedSize(), target, stream);
1109   }
1110 
1111   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1112     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1113         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1114   }
1115   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.SavedTensorSlices)
1116   return target;
1117 }
1118 
ByteSizeLong() const1119 size_t SavedTensorSlices::ByteSizeLong() const {
1120 // @@protoc_insertion_point(message_byte_size_start:tensorflow.SavedTensorSlices)
1121   size_t total_size = 0;
1122 
1123   ::uint32_t cached_has_bits = 0;
1124   // Prevent compiler warnings about cached_has_bits being unused
1125   (void) cached_has_bits;
1126 
1127   // .tensorflow.SavedTensorSliceMeta meta = 1;
1128   if (this->_internal_has_meta()) {
1129     total_size += 1 +
1130       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1131         *_impl_.meta_);
1132   }
1133 
1134   // .tensorflow.SavedSlice data = 2;
1135   if (this->_internal_has_data()) {
1136     total_size += 1 +
1137       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1138         *_impl_.data_);
1139   }
1140 
1141   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1142     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1143   }
1144   int cached_size = ::_pbi::ToCachedSize(total_size);
1145   SetCachedSize(cached_size);
1146   return total_size;
1147 }
1148 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1149 void SavedTensorSlices::CheckTypeAndMergeFrom(
1150     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1151   MergeFrom(*::_pbi::DownCast<const SavedTensorSlices*>(
1152       &from));
1153 }
1154 
MergeFrom(const SavedTensorSlices & from)1155 void SavedTensorSlices::MergeFrom(const SavedTensorSlices& from) {
1156   SavedTensorSlices* const _this = this;
1157   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.SavedTensorSlices)
1158   GOOGLE_DCHECK_NE(&from, _this);
1159   ::uint32_t cached_has_bits = 0;
1160   (void) cached_has_bits;
1161 
1162   if (from._internal_has_meta()) {
1163     _this->_internal_mutable_meta()->::tensorflow::SavedTensorSliceMeta::MergeFrom(
1164         from._internal_meta());
1165   }
1166   if (from._internal_has_data()) {
1167     _this->_internal_mutable_data()->::tensorflow::SavedSlice::MergeFrom(
1168         from._internal_data());
1169   }
1170   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1171 }
1172 
CopyFrom(const SavedTensorSlices & from)1173 void SavedTensorSlices::CopyFrom(const SavedTensorSlices& from) {
1174 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.SavedTensorSlices)
1175   if (&from == this) return;
1176   Clear();
1177   MergeFrom(from);
1178 }
1179 
IsInitialized() const1180 bool SavedTensorSlices::IsInitialized() const {
1181   return true;
1182 }
1183 
InternalSwap(SavedTensorSlices * other)1184 void SavedTensorSlices::InternalSwap(SavedTensorSlices* other) {
1185   using std::swap;
1186   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1187   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1188       PROTOBUF_FIELD_OFFSET(SavedTensorSlices, _impl_.data_)
1189       + sizeof(SavedTensorSlices::_impl_.data_)  // NOLINT
1190       - PROTOBUF_FIELD_OFFSET(SavedTensorSlices, _impl_.meta_)>(
1191           reinterpret_cast<char*>(&_impl_.meta_),
1192           reinterpret_cast<char*>(&other->_impl_.meta_));
1193 }
1194 
GetTypeName() const1195 std::string SavedTensorSlices::GetTypeName() const {
1196   return "tensorflow.SavedTensorSlices";
1197 }
1198 
1199 
1200 // @@protoc_insertion_point(namespace_scope)
1201 }  // namespace tensorflow
1202 PROTOBUF_NAMESPACE_OPEN
1203 template<> PROTOBUF_NOINLINE ::tensorflow::SavedSliceMeta*
CreateMaybeMessage(Arena * arena)1204 Arena::CreateMaybeMessage< ::tensorflow::SavedSliceMeta >(Arena* arena) {
1205   return Arena::CreateMessageInternal< ::tensorflow::SavedSliceMeta >(arena);
1206 }
1207 template<> PROTOBUF_NOINLINE ::tensorflow::SavedTensorSliceMeta*
CreateMaybeMessage(Arena * arena)1208 Arena::CreateMaybeMessage< ::tensorflow::SavedTensorSliceMeta >(Arena* arena) {
1209   return Arena::CreateMessageInternal< ::tensorflow::SavedTensorSliceMeta >(arena);
1210 }
1211 template<> PROTOBUF_NOINLINE ::tensorflow::SavedSlice*
CreateMaybeMessage(Arena * arena)1212 Arena::CreateMaybeMessage< ::tensorflow::SavedSlice >(Arena* arena) {
1213   return Arena::CreateMessageInternal< ::tensorflow::SavedSlice >(arena);
1214 }
1215 template<> PROTOBUF_NOINLINE ::tensorflow::SavedTensorSlices*
CreateMaybeMessage(Arena * arena)1216 Arena::CreateMaybeMessage< ::tensorflow::SavedTensorSlices >(Arena* arena) {
1217   return Arena::CreateMessageInternal< ::tensorflow::SavedTensorSlices >(arena);
1218 }
1219 PROTOBUF_NAMESPACE_CLOSE
1220 
1221 // @@protoc_insertion_point(global_scope)
1222 #include <google/protobuf/port_undef.inc>
1223