1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/example/feature.proto
3 
4 #include "tensorflow/core/example/feature.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 {
BytesList(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR BytesList::BytesList(
23     ::_pbi::ConstantInitialized): _impl_{
24     /*decltype(_impl_.value_)*/{}
25   , /*decltype(_impl_._cached_size_)*/{}} {}
26 struct BytesListDefaultTypeInternal {
BytesListDefaultTypeInternaltensorflow::BytesListDefaultTypeInternal27   PROTOBUF_CONSTEXPR BytesListDefaultTypeInternal()
28       : _instance(::_pbi::ConstantInitialized{}) {}
~BytesListDefaultTypeInternaltensorflow::BytesListDefaultTypeInternal29   ~BytesListDefaultTypeInternal() {}
30   union {  // NOLINT(misc-non-private-member-variables-in-classes)
31     BytesList _instance;
32   };
33 };
34 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BytesListDefaultTypeInternal _BytesList_default_instance_;
FloatList(::_pbi::ConstantInitialized)35 PROTOBUF_CONSTEXPR FloatList::FloatList(
36     ::_pbi::ConstantInitialized): _impl_{
37     /*decltype(_impl_.value_)*/{}
38   , /*decltype(_impl_._cached_size_)*/{}} {}
39 struct FloatListDefaultTypeInternal {
FloatListDefaultTypeInternaltensorflow::FloatListDefaultTypeInternal40   PROTOBUF_CONSTEXPR FloatListDefaultTypeInternal()
41       : _instance(::_pbi::ConstantInitialized{}) {}
~FloatListDefaultTypeInternaltensorflow::FloatListDefaultTypeInternal42   ~FloatListDefaultTypeInternal() {}
43   union {  // NOLINT(misc-non-private-member-variables-in-classes)
44     FloatList _instance;
45   };
46 };
47 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FloatListDefaultTypeInternal _FloatList_default_instance_;
Int64List(::_pbi::ConstantInitialized)48 PROTOBUF_CONSTEXPR Int64List::Int64List(
49     ::_pbi::ConstantInitialized): _impl_{
50     /*decltype(_impl_.value_)*/{}
51   , /*decltype(_impl_._value_cached_byte_size_)*/{0}
52   , /*decltype(_impl_._cached_size_)*/{}} {}
53 struct Int64ListDefaultTypeInternal {
Int64ListDefaultTypeInternaltensorflow::Int64ListDefaultTypeInternal54   PROTOBUF_CONSTEXPR Int64ListDefaultTypeInternal()
55       : _instance(::_pbi::ConstantInitialized{}) {}
~Int64ListDefaultTypeInternaltensorflow::Int64ListDefaultTypeInternal56   ~Int64ListDefaultTypeInternal() {}
57   union {  // NOLINT(misc-non-private-member-variables-in-classes)
58     Int64List _instance;
59   };
60 };
61 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Int64ListDefaultTypeInternal _Int64List_default_instance_;
Feature(::_pbi::ConstantInitialized)62 PROTOBUF_CONSTEXPR Feature::Feature(
63     ::_pbi::ConstantInitialized): _impl_{
64     /*decltype(_impl_.kind_)*/{}
65   , /*decltype(_impl_._cached_size_)*/{}
66   , /*decltype(_impl_._oneof_case_)*/{}} {}
67 struct FeatureDefaultTypeInternal {
FeatureDefaultTypeInternaltensorflow::FeatureDefaultTypeInternal68   PROTOBUF_CONSTEXPR FeatureDefaultTypeInternal()
69       : _instance(::_pbi::ConstantInitialized{}) {}
~FeatureDefaultTypeInternaltensorflow::FeatureDefaultTypeInternal70   ~FeatureDefaultTypeInternal() {}
71   union {  // NOLINT(misc-non-private-member-variables-in-classes)
72     Feature _instance;
73   };
74 };
75 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureDefaultTypeInternal _Feature_default_instance_;
Features_FeatureEntry_DoNotUse(::_pbi::ConstantInitialized)76 PROTOBUF_CONSTEXPR Features_FeatureEntry_DoNotUse::Features_FeatureEntry_DoNotUse(
77     ::_pbi::ConstantInitialized) {}
78 struct Features_FeatureEntry_DoNotUseDefaultTypeInternal {
Features_FeatureEntry_DoNotUseDefaultTypeInternaltensorflow::Features_FeatureEntry_DoNotUseDefaultTypeInternal79   PROTOBUF_CONSTEXPR Features_FeatureEntry_DoNotUseDefaultTypeInternal()
80       : _instance(::_pbi::ConstantInitialized{}) {}
~Features_FeatureEntry_DoNotUseDefaultTypeInternaltensorflow::Features_FeatureEntry_DoNotUseDefaultTypeInternal81   ~Features_FeatureEntry_DoNotUseDefaultTypeInternal() {}
82   union {  // NOLINT(misc-non-private-member-variables-in-classes)
83     Features_FeatureEntry_DoNotUse _instance;
84   };
85 };
86 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 Features_FeatureEntry_DoNotUseDefaultTypeInternal _Features_FeatureEntry_DoNotUse_default_instance_;
Features(::_pbi::ConstantInitialized)87 PROTOBUF_CONSTEXPR Features::Features(
88     ::_pbi::ConstantInitialized): _impl_{
89     /*decltype(_impl_.feature_)*/{}
90   , /*decltype(_impl_._cached_size_)*/{}} {}
91 struct FeaturesDefaultTypeInternal {
FeaturesDefaultTypeInternaltensorflow::FeaturesDefaultTypeInternal92   PROTOBUF_CONSTEXPR FeaturesDefaultTypeInternal()
93       : _instance(::_pbi::ConstantInitialized{}) {}
~FeaturesDefaultTypeInternaltensorflow::FeaturesDefaultTypeInternal94   ~FeaturesDefaultTypeInternal() {}
95   union {  // NOLINT(misc-non-private-member-variables-in-classes)
96     Features _instance;
97   };
98 };
99 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeaturesDefaultTypeInternal _Features_default_instance_;
FeatureList(::_pbi::ConstantInitialized)100 PROTOBUF_CONSTEXPR FeatureList::FeatureList(
101     ::_pbi::ConstantInitialized): _impl_{
102     /*decltype(_impl_.feature_)*/{}
103   , /*decltype(_impl_._cached_size_)*/{}} {}
104 struct FeatureListDefaultTypeInternal {
FeatureListDefaultTypeInternaltensorflow::FeatureListDefaultTypeInternal105   PROTOBUF_CONSTEXPR FeatureListDefaultTypeInternal()
106       : _instance(::_pbi::ConstantInitialized{}) {}
~FeatureListDefaultTypeInternaltensorflow::FeatureListDefaultTypeInternal107   ~FeatureListDefaultTypeInternal() {}
108   union {  // NOLINT(misc-non-private-member-variables-in-classes)
109     FeatureList _instance;
110   };
111 };
112 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureListDefaultTypeInternal _FeatureList_default_instance_;
FeatureLists_FeatureListEntry_DoNotUse(::_pbi::ConstantInitialized)113 PROTOBUF_CONSTEXPR FeatureLists_FeatureListEntry_DoNotUse::FeatureLists_FeatureListEntry_DoNotUse(
114     ::_pbi::ConstantInitialized) {}
115 struct FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal {
FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternaltensorflow::FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal116   PROTOBUF_CONSTEXPR FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal()
117       : _instance(::_pbi::ConstantInitialized{}) {}
~FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternaltensorflow::FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal118   ~FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal() {}
119   union {  // NOLINT(misc-non-private-member-variables-in-classes)
120     FeatureLists_FeatureListEntry_DoNotUse _instance;
121   };
122 };
123 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureLists_FeatureListEntry_DoNotUseDefaultTypeInternal _FeatureLists_FeatureListEntry_DoNotUse_default_instance_;
FeatureLists(::_pbi::ConstantInitialized)124 PROTOBUF_CONSTEXPR FeatureLists::FeatureLists(
125     ::_pbi::ConstantInitialized): _impl_{
126     /*decltype(_impl_.feature_list_)*/{}
127   , /*decltype(_impl_._cached_size_)*/{}} {}
128 struct FeatureListsDefaultTypeInternal {
FeatureListsDefaultTypeInternaltensorflow::FeatureListsDefaultTypeInternal129   PROTOBUF_CONSTEXPR FeatureListsDefaultTypeInternal()
130       : _instance(::_pbi::ConstantInitialized{}) {}
~FeatureListsDefaultTypeInternaltensorflow::FeatureListsDefaultTypeInternal131   ~FeatureListsDefaultTypeInternal() {}
132   union {  // NOLINT(misc-non-private-member-variables-in-classes)
133     FeatureLists _instance;
134   };
135 };
136 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeatureListsDefaultTypeInternal _FeatureLists_default_instance_;
137 }  // namespace tensorflow
138 namespace tensorflow {
139 
140 // ===================================================================
141 
142 class BytesList::_Internal {
143  public:
144 };
145 
BytesList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)146 BytesList::BytesList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
147                          bool is_message_owned)
148   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
149   SharedCtor(arena, is_message_owned);
150   // @@protoc_insertion_point(arena_constructor:tensorflow.BytesList)
151 }
BytesList(const BytesList & from)152 BytesList::BytesList(const BytesList& from)
153   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
154   BytesList* const _this = this; (void)_this;
155   new (&_impl_) Impl_{
156       decltype(_impl_.value_){from._impl_.value_}
157     , /*decltype(_impl_._cached_size_)*/{}};
158 
159   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
160   // @@protoc_insertion_point(copy_constructor:tensorflow.BytesList)
161 }
162 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)163 inline void BytesList::SharedCtor(
164     ::_pb::Arena* arena, bool is_message_owned) {
165   (void)arena;
166   (void)is_message_owned;
167   new (&_impl_) Impl_{
168       decltype(_impl_.value_){arena}
169     , /*decltype(_impl_._cached_size_)*/{}
170   };
171 }
172 
~BytesList()173 BytesList::~BytesList() {
174   // @@protoc_insertion_point(destructor:tensorflow.BytesList)
175   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
176   (void)arena;
177     return;
178   }
179   SharedDtor();
180 }
181 
SharedDtor()182 inline void BytesList::SharedDtor() {
183   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
184   _impl_.value_.~RepeatedPtrField();
185 }
186 
SetCachedSize(int size) const187 void BytesList::SetCachedSize(int size) const {
188   _impl_._cached_size_.Set(size);
189 }
190 
Clear()191 void BytesList::Clear() {
192 // @@protoc_insertion_point(message_clear_start:tensorflow.BytesList)
193   ::uint32_t cached_has_bits = 0;
194   // Prevent compiler warnings about cached_has_bits being unused
195   (void) cached_has_bits;
196 
197   _impl_.value_.Clear();
198   _internal_metadata_.Clear<std::string>();
199 }
200 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)201 const char* BytesList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
202 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
203   while (!ctx->Done(&ptr)) {
204     ::uint32_t tag;
205     ptr = ::_pbi::ReadTag(ptr, &tag);
206     switch (tag >> 3) {
207       // repeated bytes value = 1;
208       case 1:
209         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
210           ptr -= 1;
211           do {
212             ptr += 1;
213             auto str = _internal_add_value();
214             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
215             CHK_(ptr);
216             if (!ctx->DataAvailable(ptr)) break;
217           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
218         } else {
219           goto handle_unusual;
220         }
221         continue;
222       default:
223         goto handle_unusual;
224     }  // switch
225   handle_unusual:
226     if ((tag == 0) || ((tag & 7) == 4)) {
227       CHK_(ptr);
228       ctx->SetLastTag(tag);
229       goto message_done;
230     }
231     ptr = UnknownFieldParse(
232         tag,
233         _internal_metadata_.mutable_unknown_fields<std::string>(),
234         ptr, ctx);
235     CHK_(ptr != nullptr);
236   }  // while
237 message_done:
238   return ptr;
239 failure:
240   ptr = nullptr;
241   goto message_done;
242 #undef CHK_
243 }
244 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const245 ::uint8_t* BytesList::_InternalSerialize(
246     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
247   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.BytesList)
248   ::uint32_t cached_has_bits = 0;
249   (void) cached_has_bits;
250 
251   // repeated bytes value = 1;
252   for (int i = 0, n = this->_internal_value_size(); i < n; i++) {
253     const auto& s = this->_internal_value(i);
254     target = stream->WriteBytes(1, s, target);
255   }
256 
257   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
258     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
259         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
260   }
261   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.BytesList)
262   return target;
263 }
264 
ByteSizeLong() const265 size_t BytesList::ByteSizeLong() const {
266 // @@protoc_insertion_point(message_byte_size_start:tensorflow.BytesList)
267   size_t total_size = 0;
268 
269   ::uint32_t cached_has_bits = 0;
270   // Prevent compiler warnings about cached_has_bits being unused
271   (void) cached_has_bits;
272 
273   // repeated bytes value = 1;
274   total_size += 1 *
275       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.value_.size());
276   for (int i = 0, n = _impl_.value_.size(); i < n; i++) {
277     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
278       _impl_.value_.Get(i));
279   }
280 
281   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
282     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
283   }
284   int cached_size = ::_pbi::ToCachedSize(total_size);
285   SetCachedSize(cached_size);
286   return total_size;
287 }
288 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)289 void BytesList::CheckTypeAndMergeFrom(
290     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
291   MergeFrom(*::_pbi::DownCast<const BytesList*>(
292       &from));
293 }
294 
MergeFrom(const BytesList & from)295 void BytesList::MergeFrom(const BytesList& from) {
296   BytesList* const _this = this;
297   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.BytesList)
298   GOOGLE_DCHECK_NE(&from, _this);
299   ::uint32_t cached_has_bits = 0;
300   (void) cached_has_bits;
301 
302   _this->_impl_.value_.MergeFrom(from._impl_.value_);
303   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
304 }
305 
CopyFrom(const BytesList & from)306 void BytesList::CopyFrom(const BytesList& from) {
307 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.BytesList)
308   if (&from == this) return;
309   Clear();
310   MergeFrom(from);
311 }
312 
IsInitialized() const313 bool BytesList::IsInitialized() const {
314   return true;
315 }
316 
InternalSwap(BytesList * other)317 void BytesList::InternalSwap(BytesList* other) {
318   using std::swap;
319   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
320   _impl_.value_.InternalSwap(&other->_impl_.value_);
321 }
322 
GetTypeName() const323 std::string BytesList::GetTypeName() const {
324   return "tensorflow.BytesList";
325 }
326 
327 
328 // ===================================================================
329 
330 class FloatList::_Internal {
331  public:
332 };
333 
FloatList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)334 FloatList::FloatList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
335                          bool is_message_owned)
336   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
337   SharedCtor(arena, is_message_owned);
338   // @@protoc_insertion_point(arena_constructor:tensorflow.FloatList)
339 }
FloatList(const FloatList & from)340 FloatList::FloatList(const FloatList& from)
341   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
342   FloatList* const _this = this; (void)_this;
343   new (&_impl_) Impl_{
344       decltype(_impl_.value_){from._impl_.value_}
345     , /*decltype(_impl_._cached_size_)*/{}};
346 
347   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
348   // @@protoc_insertion_point(copy_constructor:tensorflow.FloatList)
349 }
350 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)351 inline void FloatList::SharedCtor(
352     ::_pb::Arena* arena, bool is_message_owned) {
353   (void)arena;
354   (void)is_message_owned;
355   new (&_impl_) Impl_{
356       decltype(_impl_.value_){arena}
357     , /*decltype(_impl_._cached_size_)*/{}
358   };
359 }
360 
~FloatList()361 FloatList::~FloatList() {
362   // @@protoc_insertion_point(destructor:tensorflow.FloatList)
363   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
364   (void)arena;
365     return;
366   }
367   SharedDtor();
368 }
369 
SharedDtor()370 inline void FloatList::SharedDtor() {
371   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
372   _impl_.value_.~RepeatedField();
373 }
374 
SetCachedSize(int size) const375 void FloatList::SetCachedSize(int size) const {
376   _impl_._cached_size_.Set(size);
377 }
378 
Clear()379 void FloatList::Clear() {
380 // @@protoc_insertion_point(message_clear_start:tensorflow.FloatList)
381   ::uint32_t cached_has_bits = 0;
382   // Prevent compiler warnings about cached_has_bits being unused
383   (void) cached_has_bits;
384 
385   _impl_.value_.Clear();
386   _internal_metadata_.Clear<std::string>();
387 }
388 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)389 const char* FloatList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
390 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
391   while (!ctx->Done(&ptr)) {
392     ::uint32_t tag;
393     ptr = ::_pbi::ReadTag(ptr, &tag);
394     switch (tag >> 3) {
395       // repeated float value = 1 [packed = true];
396       case 1:
397         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
398           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(_internal_mutable_value(), ptr, ctx);
399           CHK_(ptr);
400         } else if (static_cast<::uint8_t>(tag) == 13) {
401           _internal_add_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
402           ptr += sizeof(float);
403         } else {
404           goto handle_unusual;
405         }
406         continue;
407       default:
408         goto handle_unusual;
409     }  // switch
410   handle_unusual:
411     if ((tag == 0) || ((tag & 7) == 4)) {
412       CHK_(ptr);
413       ctx->SetLastTag(tag);
414       goto message_done;
415     }
416     ptr = UnknownFieldParse(
417         tag,
418         _internal_metadata_.mutable_unknown_fields<std::string>(),
419         ptr, ctx);
420     CHK_(ptr != nullptr);
421   }  // while
422 message_done:
423   return ptr;
424 failure:
425   ptr = nullptr;
426   goto message_done;
427 #undef CHK_
428 }
429 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const430 ::uint8_t* FloatList::_InternalSerialize(
431     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
432   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FloatList)
433   ::uint32_t cached_has_bits = 0;
434   (void) cached_has_bits;
435 
436   // repeated float value = 1 [packed = true];
437   if (this->_internal_value_size() > 0) {
438     target = stream->WriteFixedPacked(1, _internal_value(), target);
439   }
440 
441   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
442     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
443         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
444   }
445   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FloatList)
446   return target;
447 }
448 
ByteSizeLong() const449 size_t FloatList::ByteSizeLong() const {
450 // @@protoc_insertion_point(message_byte_size_start:tensorflow.FloatList)
451   size_t total_size = 0;
452 
453   ::uint32_t cached_has_bits = 0;
454   // Prevent compiler warnings about cached_has_bits being unused
455   (void) cached_has_bits;
456 
457   // repeated float value = 1 [packed = true];
458   {
459     unsigned int count = static_cast<unsigned int>(this->_internal_value_size());
460     size_t data_size = 4UL * count;
461     if (data_size > 0) {
462       total_size += 1 +
463         ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
464     }
465     total_size += data_size;
466   }
467 
468   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
469     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
470   }
471   int cached_size = ::_pbi::ToCachedSize(total_size);
472   SetCachedSize(cached_size);
473   return total_size;
474 }
475 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)476 void FloatList::CheckTypeAndMergeFrom(
477     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
478   MergeFrom(*::_pbi::DownCast<const FloatList*>(
479       &from));
480 }
481 
MergeFrom(const FloatList & from)482 void FloatList::MergeFrom(const FloatList& from) {
483   FloatList* const _this = this;
484   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FloatList)
485   GOOGLE_DCHECK_NE(&from, _this);
486   ::uint32_t cached_has_bits = 0;
487   (void) cached_has_bits;
488 
489   _this->_impl_.value_.MergeFrom(from._impl_.value_);
490   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
491 }
492 
CopyFrom(const FloatList & from)493 void FloatList::CopyFrom(const FloatList& from) {
494 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FloatList)
495   if (&from == this) return;
496   Clear();
497   MergeFrom(from);
498 }
499 
IsInitialized() const500 bool FloatList::IsInitialized() const {
501   return true;
502 }
503 
InternalSwap(FloatList * other)504 void FloatList::InternalSwap(FloatList* other) {
505   using std::swap;
506   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
507   _impl_.value_.InternalSwap(&other->_impl_.value_);
508 }
509 
GetTypeName() const510 std::string FloatList::GetTypeName() const {
511   return "tensorflow.FloatList";
512 }
513 
514 
515 // ===================================================================
516 
517 class Int64List::_Internal {
518  public:
519 };
520 
Int64List(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)521 Int64List::Int64List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
522                          bool is_message_owned)
523   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
524   SharedCtor(arena, is_message_owned);
525   // @@protoc_insertion_point(arena_constructor:tensorflow.Int64List)
526 }
Int64List(const Int64List & from)527 Int64List::Int64List(const Int64List& from)
528   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
529   Int64List* const _this = this; (void)_this;
530   new (&_impl_) Impl_{
531       decltype(_impl_.value_){from._impl_.value_}
532     , /*decltype(_impl_._value_cached_byte_size_)*/{0}
533     , /*decltype(_impl_._cached_size_)*/{}};
534 
535   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
536   // @@protoc_insertion_point(copy_constructor:tensorflow.Int64List)
537 }
538 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)539 inline void Int64List::SharedCtor(
540     ::_pb::Arena* arena, bool is_message_owned) {
541   (void)arena;
542   (void)is_message_owned;
543   new (&_impl_) Impl_{
544       decltype(_impl_.value_){arena}
545     , /*decltype(_impl_._value_cached_byte_size_)*/{0}
546     , /*decltype(_impl_._cached_size_)*/{}
547   };
548 }
549 
~Int64List()550 Int64List::~Int64List() {
551   // @@protoc_insertion_point(destructor:tensorflow.Int64List)
552   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
553   (void)arena;
554     return;
555   }
556   SharedDtor();
557 }
558 
SharedDtor()559 inline void Int64List::SharedDtor() {
560   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
561   _impl_.value_.~RepeatedField();
562 }
563 
SetCachedSize(int size) const564 void Int64List::SetCachedSize(int size) const {
565   _impl_._cached_size_.Set(size);
566 }
567 
Clear()568 void Int64List::Clear() {
569 // @@protoc_insertion_point(message_clear_start:tensorflow.Int64List)
570   ::uint32_t cached_has_bits = 0;
571   // Prevent compiler warnings about cached_has_bits being unused
572   (void) cached_has_bits;
573 
574   _impl_.value_.Clear();
575   _internal_metadata_.Clear<std::string>();
576 }
577 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)578 const char* Int64List::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
579 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
580   while (!ctx->Done(&ptr)) {
581     ::uint32_t tag;
582     ptr = ::_pbi::ReadTag(ptr, &tag);
583     switch (tag >> 3) {
584       // repeated int64 value = 1 [packed = true];
585       case 1:
586         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
587           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_value(), ptr, ctx);
588           CHK_(ptr);
589         } else if (static_cast<::uint8_t>(tag) == 8) {
590           _internal_add_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
591           CHK_(ptr);
592         } else {
593           goto handle_unusual;
594         }
595         continue;
596       default:
597         goto handle_unusual;
598     }  // switch
599   handle_unusual:
600     if ((tag == 0) || ((tag & 7) == 4)) {
601       CHK_(ptr);
602       ctx->SetLastTag(tag);
603       goto message_done;
604     }
605     ptr = UnknownFieldParse(
606         tag,
607         _internal_metadata_.mutable_unknown_fields<std::string>(),
608         ptr, ctx);
609     CHK_(ptr != nullptr);
610   }  // while
611 message_done:
612   return ptr;
613 failure:
614   ptr = nullptr;
615   goto message_done;
616 #undef CHK_
617 }
618 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const619 ::uint8_t* Int64List::_InternalSerialize(
620     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
621   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.Int64List)
622   ::uint32_t cached_has_bits = 0;
623   (void) cached_has_bits;
624 
625   // repeated int64 value = 1 [packed = true];
626   {
627     int byte_size = _impl_._value_cached_byte_size_.load(std::memory_order_relaxed);
628     if (byte_size > 0) {
629       target = stream->WriteInt64Packed(
630           1, _internal_value(), byte_size, target);
631     }
632   }
633 
634   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
635     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
636         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
637   }
638   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.Int64List)
639   return target;
640 }
641 
ByteSizeLong() const642 size_t Int64List::ByteSizeLong() const {
643 // @@protoc_insertion_point(message_byte_size_start:tensorflow.Int64List)
644   size_t total_size = 0;
645 
646   ::uint32_t cached_has_bits = 0;
647   // Prevent compiler warnings about cached_has_bits being unused
648   (void) cached_has_bits;
649 
650   // repeated int64 value = 1 [packed = true];
651   {
652     size_t data_size = ::_pbi::WireFormatLite::
653       Int64Size(this->_impl_.value_);
654     if (data_size > 0) {
655       total_size += 1 +
656         ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
657     }
658     int cached_size = ::_pbi::ToCachedSize(data_size);
659     _impl_._value_cached_byte_size_.store(cached_size,
660                                     std::memory_order_relaxed);
661     total_size += data_size;
662   }
663 
664   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
665     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
666   }
667   int cached_size = ::_pbi::ToCachedSize(total_size);
668   SetCachedSize(cached_size);
669   return total_size;
670 }
671 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)672 void Int64List::CheckTypeAndMergeFrom(
673     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
674   MergeFrom(*::_pbi::DownCast<const Int64List*>(
675       &from));
676 }
677 
MergeFrom(const Int64List & from)678 void Int64List::MergeFrom(const Int64List& from) {
679   Int64List* const _this = this;
680   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.Int64List)
681   GOOGLE_DCHECK_NE(&from, _this);
682   ::uint32_t cached_has_bits = 0;
683   (void) cached_has_bits;
684 
685   _this->_impl_.value_.MergeFrom(from._impl_.value_);
686   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
687 }
688 
CopyFrom(const Int64List & from)689 void Int64List::CopyFrom(const Int64List& from) {
690 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.Int64List)
691   if (&from == this) return;
692   Clear();
693   MergeFrom(from);
694 }
695 
IsInitialized() const696 bool Int64List::IsInitialized() const {
697   return true;
698 }
699 
InternalSwap(Int64List * other)700 void Int64List::InternalSwap(Int64List* other) {
701   using std::swap;
702   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
703   _impl_.value_.InternalSwap(&other->_impl_.value_);
704 }
705 
GetTypeName() const706 std::string Int64List::GetTypeName() const {
707   return "tensorflow.Int64List";
708 }
709 
710 
711 // ===================================================================
712 
713 class Feature::_Internal {
714  public:
715   static const ::tensorflow::BytesList& bytes_list(const Feature* msg);
716   static const ::tensorflow::FloatList& float_list(const Feature* msg);
717   static const ::tensorflow::Int64List& int64_list(const Feature* msg);
718 };
719 
720 const ::tensorflow::BytesList&
bytes_list(const Feature * msg)721 Feature::_Internal::bytes_list(const Feature* msg) {
722   return *msg->_impl_.kind_.bytes_list_;
723 }
724 const ::tensorflow::FloatList&
float_list(const Feature * msg)725 Feature::_Internal::float_list(const Feature* msg) {
726   return *msg->_impl_.kind_.float_list_;
727 }
728 const ::tensorflow::Int64List&
int64_list(const Feature * msg)729 Feature::_Internal::int64_list(const Feature* msg) {
730   return *msg->_impl_.kind_.int64_list_;
731 }
set_allocated_bytes_list(::tensorflow::BytesList * bytes_list)732 void Feature::set_allocated_bytes_list(::tensorflow::BytesList* bytes_list) {
733   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
734   clear_kind();
735   if (bytes_list) {
736     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
737       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bytes_list);
738     if (message_arena != submessage_arena) {
739       bytes_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
740           message_arena, bytes_list, submessage_arena);
741     }
742     set_has_bytes_list();
743     _impl_.kind_.bytes_list_ = bytes_list;
744   }
745   // @@protoc_insertion_point(field_set_allocated:tensorflow.Feature.bytes_list)
746 }
set_allocated_float_list(::tensorflow::FloatList * float_list)747 void Feature::set_allocated_float_list(::tensorflow::FloatList* float_list) {
748   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
749   clear_kind();
750   if (float_list) {
751     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
752       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(float_list);
753     if (message_arena != submessage_arena) {
754       float_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
755           message_arena, float_list, submessage_arena);
756     }
757     set_has_float_list();
758     _impl_.kind_.float_list_ = float_list;
759   }
760   // @@protoc_insertion_point(field_set_allocated:tensorflow.Feature.float_list)
761 }
set_allocated_int64_list(::tensorflow::Int64List * int64_list)762 void Feature::set_allocated_int64_list(::tensorflow::Int64List* int64_list) {
763   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
764   clear_kind();
765   if (int64_list) {
766     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
767       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(int64_list);
768     if (message_arena != submessage_arena) {
769       int64_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
770           message_arena, int64_list, submessage_arena);
771     }
772     set_has_int64_list();
773     _impl_.kind_.int64_list_ = int64_list;
774   }
775   // @@protoc_insertion_point(field_set_allocated:tensorflow.Feature.int64_list)
776 }
Feature(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)777 Feature::Feature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
778                          bool is_message_owned)
779   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
780   SharedCtor(arena, is_message_owned);
781   // @@protoc_insertion_point(arena_constructor:tensorflow.Feature)
782 }
Feature(const Feature & from)783 Feature::Feature(const Feature& from)
784   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
785   Feature* const _this = this; (void)_this;
786   new (&_impl_) Impl_{
787       decltype(_impl_.kind_){}
788     , /*decltype(_impl_._cached_size_)*/{}
789     , /*decltype(_impl_._oneof_case_)*/{}};
790 
791   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
792   clear_has_kind();
793   switch (from.kind_case()) {
794     case kBytesList: {
795       _this->_internal_mutable_bytes_list()->::tensorflow::BytesList::MergeFrom(
796           from._internal_bytes_list());
797       break;
798     }
799     case kFloatList: {
800       _this->_internal_mutable_float_list()->::tensorflow::FloatList::MergeFrom(
801           from._internal_float_list());
802       break;
803     }
804     case kInt64List: {
805       _this->_internal_mutable_int64_list()->::tensorflow::Int64List::MergeFrom(
806           from._internal_int64_list());
807       break;
808     }
809     case KIND_NOT_SET: {
810       break;
811     }
812   }
813   // @@protoc_insertion_point(copy_constructor:tensorflow.Feature)
814 }
815 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)816 inline void Feature::SharedCtor(
817     ::_pb::Arena* arena, bool is_message_owned) {
818   (void)arena;
819   (void)is_message_owned;
820   new (&_impl_) Impl_{
821       decltype(_impl_.kind_){}
822     , /*decltype(_impl_._cached_size_)*/{}
823     , /*decltype(_impl_._oneof_case_)*/{}
824   };
825   clear_has_kind();
826 }
827 
~Feature()828 Feature::~Feature() {
829   // @@protoc_insertion_point(destructor:tensorflow.Feature)
830   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
831   (void)arena;
832     return;
833   }
834   SharedDtor();
835 }
836 
SharedDtor()837 inline void Feature::SharedDtor() {
838   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
839   if (has_kind()) {
840     clear_kind();
841   }
842 }
843 
SetCachedSize(int size) const844 void Feature::SetCachedSize(int size) const {
845   _impl_._cached_size_.Set(size);
846 }
847 
clear_kind()848 void Feature::clear_kind() {
849 // @@protoc_insertion_point(one_of_clear_start:tensorflow.Feature)
850   switch (kind_case()) {
851     case kBytesList: {
852       if (GetArenaForAllocation() == nullptr) {
853         delete _impl_.kind_.bytes_list_;
854       }
855       break;
856     }
857     case kFloatList: {
858       if (GetArenaForAllocation() == nullptr) {
859         delete _impl_.kind_.float_list_;
860       }
861       break;
862     }
863     case kInt64List: {
864       if (GetArenaForAllocation() == nullptr) {
865         delete _impl_.kind_.int64_list_;
866       }
867       break;
868     }
869     case KIND_NOT_SET: {
870       break;
871     }
872   }
873   _impl_._oneof_case_[0] = KIND_NOT_SET;
874 }
875 
876 
Clear()877 void Feature::Clear() {
878 // @@protoc_insertion_point(message_clear_start:tensorflow.Feature)
879   ::uint32_t cached_has_bits = 0;
880   // Prevent compiler warnings about cached_has_bits being unused
881   (void) cached_has_bits;
882 
883   clear_kind();
884   _internal_metadata_.Clear<std::string>();
885 }
886 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)887 const char* Feature::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
888 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
889   while (!ctx->Done(&ptr)) {
890     ::uint32_t tag;
891     ptr = ::_pbi::ReadTag(ptr, &tag);
892     switch (tag >> 3) {
893       // .tensorflow.BytesList bytes_list = 1;
894       case 1:
895         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
896           ptr = ctx->ParseMessage(_internal_mutable_bytes_list(), ptr);
897           CHK_(ptr);
898         } else {
899           goto handle_unusual;
900         }
901         continue;
902       // .tensorflow.FloatList float_list = 2;
903       case 2:
904         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
905           ptr = ctx->ParseMessage(_internal_mutable_float_list(), ptr);
906           CHK_(ptr);
907         } else {
908           goto handle_unusual;
909         }
910         continue;
911       // .tensorflow.Int64List int64_list = 3;
912       case 3:
913         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
914           ptr = ctx->ParseMessage(_internal_mutable_int64_list(), ptr);
915           CHK_(ptr);
916         } else {
917           goto handle_unusual;
918         }
919         continue;
920       default:
921         goto handle_unusual;
922     }  // switch
923   handle_unusual:
924     if ((tag == 0) || ((tag & 7) == 4)) {
925       CHK_(ptr);
926       ctx->SetLastTag(tag);
927       goto message_done;
928     }
929     ptr = UnknownFieldParse(
930         tag,
931         _internal_metadata_.mutable_unknown_fields<std::string>(),
932         ptr, ctx);
933     CHK_(ptr != nullptr);
934   }  // while
935 message_done:
936   return ptr;
937 failure:
938   ptr = nullptr;
939   goto message_done;
940 #undef CHK_
941 }
942 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const943 ::uint8_t* Feature::_InternalSerialize(
944     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
945   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.Feature)
946   ::uint32_t cached_has_bits = 0;
947   (void) cached_has_bits;
948 
949   // .tensorflow.BytesList bytes_list = 1;
950   if (_internal_has_bytes_list()) {
951     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
952       InternalWriteMessage(1, _Internal::bytes_list(this),
953         _Internal::bytes_list(this).GetCachedSize(), target, stream);
954   }
955 
956   // .tensorflow.FloatList float_list = 2;
957   if (_internal_has_float_list()) {
958     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
959       InternalWriteMessage(2, _Internal::float_list(this),
960         _Internal::float_list(this).GetCachedSize(), target, stream);
961   }
962 
963   // .tensorflow.Int64List int64_list = 3;
964   if (_internal_has_int64_list()) {
965     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
966       InternalWriteMessage(3, _Internal::int64_list(this),
967         _Internal::int64_list(this).GetCachedSize(), target, stream);
968   }
969 
970   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
971     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
972         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
973   }
974   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.Feature)
975   return target;
976 }
977 
ByteSizeLong() const978 size_t Feature::ByteSizeLong() const {
979 // @@protoc_insertion_point(message_byte_size_start:tensorflow.Feature)
980   size_t total_size = 0;
981 
982   switch (kind_case()) {
983     // .tensorflow.BytesList bytes_list = 1;
984     case kBytesList: {
985       total_size += 1 +
986         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
987           *_impl_.kind_.bytes_list_);
988       break;
989     }
990     // .tensorflow.FloatList float_list = 2;
991     case kFloatList: {
992       total_size += 1 +
993         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
994           *_impl_.kind_.float_list_);
995       break;
996     }
997     // .tensorflow.Int64List int64_list = 3;
998     case kInt64List: {
999       total_size += 1 +
1000         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1001           *_impl_.kind_.int64_list_);
1002       break;
1003     }
1004     case KIND_NOT_SET: {
1005       break;
1006     }
1007   }
1008   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1009     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1010   }
1011   int cached_size = ::_pbi::ToCachedSize(total_size);
1012   SetCachedSize(cached_size);
1013   return total_size;
1014 }
1015 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1016 void Feature::CheckTypeAndMergeFrom(
1017     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1018   MergeFrom(*::_pbi::DownCast<const Feature*>(
1019       &from));
1020 }
1021 
MergeFrom(const Feature & from)1022 void Feature::MergeFrom(const Feature& from) {
1023   Feature* const _this = this;
1024   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.Feature)
1025   GOOGLE_DCHECK_NE(&from, _this);
1026   ::uint32_t cached_has_bits = 0;
1027   (void) cached_has_bits;
1028 
1029   switch (from.kind_case()) {
1030     case kBytesList: {
1031       _this->_internal_mutable_bytes_list()->::tensorflow::BytesList::MergeFrom(
1032           from._internal_bytes_list());
1033       break;
1034     }
1035     case kFloatList: {
1036       _this->_internal_mutable_float_list()->::tensorflow::FloatList::MergeFrom(
1037           from._internal_float_list());
1038       break;
1039     }
1040     case kInt64List: {
1041       _this->_internal_mutable_int64_list()->::tensorflow::Int64List::MergeFrom(
1042           from._internal_int64_list());
1043       break;
1044     }
1045     case KIND_NOT_SET: {
1046       break;
1047     }
1048   }
1049   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1050 }
1051 
CopyFrom(const Feature & from)1052 void Feature::CopyFrom(const Feature& from) {
1053 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.Feature)
1054   if (&from == this) return;
1055   Clear();
1056   MergeFrom(from);
1057 }
1058 
IsInitialized() const1059 bool Feature::IsInitialized() const {
1060   return true;
1061 }
1062 
InternalSwap(Feature * other)1063 void Feature::InternalSwap(Feature* other) {
1064   using std::swap;
1065   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1066   swap(_impl_.kind_, other->_impl_.kind_);
1067   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1068 }
1069 
GetTypeName() const1070 std::string Feature::GetTypeName() const {
1071   return "tensorflow.Feature";
1072 }
1073 
1074 
1075 // ===================================================================
1076 
Features_FeatureEntry_DoNotUse()1077 Features_FeatureEntry_DoNotUse::Features_FeatureEntry_DoNotUse() {}
Features_FeatureEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)1078 Features_FeatureEntry_DoNotUse::Features_FeatureEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
1079     : SuperType(arena) {}
MergeFrom(const Features_FeatureEntry_DoNotUse & other)1080 void Features_FeatureEntry_DoNotUse::MergeFrom(const Features_FeatureEntry_DoNotUse& other) {
1081   MergeFromInternal(other);
1082 }
1083 
1084 // ===================================================================
1085 
1086 class Features::_Internal {
1087  public:
1088 };
1089 
Features(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1090 Features::Features(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1091                          bool is_message_owned)
1092   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1093   SharedCtor(arena, is_message_owned);
1094   // @@protoc_insertion_point(arena_constructor:tensorflow.Features)
1095 }
Features(const Features & from)1096 Features::Features(const Features& from)
1097   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1098   Features* const _this = this; (void)_this;
1099   new (&_impl_) Impl_{
1100       /*decltype(_impl_.feature_)*/{}
1101     , /*decltype(_impl_._cached_size_)*/{}};
1102 
1103   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1104   _this->_impl_.feature_.MergeFrom(from._impl_.feature_);
1105   // @@protoc_insertion_point(copy_constructor:tensorflow.Features)
1106 }
1107 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1108 inline void Features::SharedCtor(
1109     ::_pb::Arena* arena, bool is_message_owned) {
1110   (void)arena;
1111   (void)is_message_owned;
1112   new (&_impl_) Impl_{
1113       /*decltype(_impl_.feature_)*/{::_pbi::ArenaInitialized(), arena}
1114     , /*decltype(_impl_._cached_size_)*/{}
1115   };
1116 }
1117 
~Features()1118 Features::~Features() {
1119   // @@protoc_insertion_point(destructor:tensorflow.Features)
1120   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1121   (void)arena;
1122     return;
1123   }
1124   SharedDtor();
1125 }
1126 
SharedDtor()1127 inline void Features::SharedDtor() {
1128   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1129   _impl_.feature_.Destruct();
1130   _impl_.feature_.~MapFieldLite();
1131 }
1132 
SetCachedSize(int size) const1133 void Features::SetCachedSize(int size) const {
1134   _impl_._cached_size_.Set(size);
1135 }
1136 
Clear()1137 void Features::Clear() {
1138 // @@protoc_insertion_point(message_clear_start:tensorflow.Features)
1139   ::uint32_t cached_has_bits = 0;
1140   // Prevent compiler warnings about cached_has_bits being unused
1141   (void) cached_has_bits;
1142 
1143   _impl_.feature_.Clear();
1144   _internal_metadata_.Clear<std::string>();
1145 }
1146 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1147 const char* Features::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1148 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1149   while (!ctx->Done(&ptr)) {
1150     ::uint32_t tag;
1151     ptr = ::_pbi::ReadTag(ptr, &tag);
1152     switch (tag >> 3) {
1153       // map<string, .tensorflow.Feature> feature = 1;
1154       case 1:
1155         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1156           ptr -= 1;
1157           do {
1158             ptr += 1;
1159             ptr = ctx->ParseMessage(&_impl_.feature_, ptr);
1160             CHK_(ptr);
1161             if (!ctx->DataAvailable(ptr)) break;
1162           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1163         } else {
1164           goto handle_unusual;
1165         }
1166         continue;
1167       default:
1168         goto handle_unusual;
1169     }  // switch
1170   handle_unusual:
1171     if ((tag == 0) || ((tag & 7) == 4)) {
1172       CHK_(ptr);
1173       ctx->SetLastTag(tag);
1174       goto message_done;
1175     }
1176     ptr = UnknownFieldParse(
1177         tag,
1178         _internal_metadata_.mutable_unknown_fields<std::string>(),
1179         ptr, ctx);
1180     CHK_(ptr != nullptr);
1181   }  // while
1182 message_done:
1183   return ptr;
1184 failure:
1185   ptr = nullptr;
1186   goto message_done;
1187 #undef CHK_
1188 }
1189 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1190 ::uint8_t* Features::_InternalSerialize(
1191     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1192   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.Features)
1193   ::uint32_t cached_has_bits = 0;
1194   (void) cached_has_bits;
1195 
1196   // map<string, .tensorflow.Feature> feature = 1;
1197   if (!this->_internal_feature().empty()) {
1198     using MapType = ::_pb::Map<std::string, ::tensorflow::Feature>;
1199     using WireHelper = Features_FeatureEntry_DoNotUse::Funcs;
1200     const auto& map_field = this->_internal_feature();
1201     auto check_utf8 = [](const MapType::value_type& entry) {
1202       (void)entry;
1203       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1204         entry.first.data(), static_cast<int>(entry.first.length()),
1205         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1206         "tensorflow.Features.FeatureEntry.key");
1207     };
1208 
1209     if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
1210       for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
1211         target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
1212         check_utf8(entry);
1213       }
1214     } else {
1215       for (const auto& entry : map_field) {
1216         target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
1217         check_utf8(entry);
1218       }
1219     }
1220   }
1221 
1222   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1223     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1224         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1225   }
1226   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.Features)
1227   return target;
1228 }
1229 
ByteSizeLong() const1230 size_t Features::ByteSizeLong() const {
1231 // @@protoc_insertion_point(message_byte_size_start:tensorflow.Features)
1232   size_t total_size = 0;
1233 
1234   ::uint32_t cached_has_bits = 0;
1235   // Prevent compiler warnings about cached_has_bits being unused
1236   (void) cached_has_bits;
1237 
1238   // map<string, .tensorflow.Feature> feature = 1;
1239   total_size += 1 *
1240       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_feature_size());
1241   for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::Feature >::const_iterator
1242       it = this->_internal_feature().begin();
1243       it != this->_internal_feature().end(); ++it) {
1244     total_size += Features_FeatureEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
1245   }
1246 
1247   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1248     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1249   }
1250   int cached_size = ::_pbi::ToCachedSize(total_size);
1251   SetCachedSize(cached_size);
1252   return total_size;
1253 }
1254 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1255 void Features::CheckTypeAndMergeFrom(
1256     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1257   MergeFrom(*::_pbi::DownCast<const Features*>(
1258       &from));
1259 }
1260 
MergeFrom(const Features & from)1261 void Features::MergeFrom(const Features& from) {
1262   Features* const _this = this;
1263   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.Features)
1264   GOOGLE_DCHECK_NE(&from, _this);
1265   ::uint32_t cached_has_bits = 0;
1266   (void) cached_has_bits;
1267 
1268   _this->_impl_.feature_.MergeFrom(from._impl_.feature_);
1269   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1270 }
1271 
CopyFrom(const Features & from)1272 void Features::CopyFrom(const Features& from) {
1273 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.Features)
1274   if (&from == this) return;
1275   Clear();
1276   MergeFrom(from);
1277 }
1278 
IsInitialized() const1279 bool Features::IsInitialized() const {
1280   return true;
1281 }
1282 
InternalSwap(Features * other)1283 void Features::InternalSwap(Features* other) {
1284   using std::swap;
1285   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1286   _impl_.feature_.InternalSwap(&other->_impl_.feature_);
1287 }
1288 
GetTypeName() const1289 std::string Features::GetTypeName() const {
1290   return "tensorflow.Features";
1291 }
1292 
1293 
1294 // ===================================================================
1295 
1296 class FeatureList::_Internal {
1297  public:
1298 };
1299 
FeatureList(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1300 FeatureList::FeatureList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1301                          bool is_message_owned)
1302   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1303   SharedCtor(arena, is_message_owned);
1304   // @@protoc_insertion_point(arena_constructor:tensorflow.FeatureList)
1305 }
FeatureList(const FeatureList & from)1306 FeatureList::FeatureList(const FeatureList& from)
1307   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1308   FeatureList* const _this = this; (void)_this;
1309   new (&_impl_) Impl_{
1310       decltype(_impl_.feature_){from._impl_.feature_}
1311     , /*decltype(_impl_._cached_size_)*/{}};
1312 
1313   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1314   // @@protoc_insertion_point(copy_constructor:tensorflow.FeatureList)
1315 }
1316 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1317 inline void FeatureList::SharedCtor(
1318     ::_pb::Arena* arena, bool is_message_owned) {
1319   (void)arena;
1320   (void)is_message_owned;
1321   new (&_impl_) Impl_{
1322       decltype(_impl_.feature_){arena}
1323     , /*decltype(_impl_._cached_size_)*/{}
1324   };
1325 }
1326 
~FeatureList()1327 FeatureList::~FeatureList() {
1328   // @@protoc_insertion_point(destructor:tensorflow.FeatureList)
1329   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1330   (void)arena;
1331     return;
1332   }
1333   SharedDtor();
1334 }
1335 
SharedDtor()1336 inline void FeatureList::SharedDtor() {
1337   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1338   _impl_.feature_.~RepeatedPtrField();
1339 }
1340 
SetCachedSize(int size) const1341 void FeatureList::SetCachedSize(int size) const {
1342   _impl_._cached_size_.Set(size);
1343 }
1344 
Clear()1345 void FeatureList::Clear() {
1346 // @@protoc_insertion_point(message_clear_start:tensorflow.FeatureList)
1347   ::uint32_t cached_has_bits = 0;
1348   // Prevent compiler warnings about cached_has_bits being unused
1349   (void) cached_has_bits;
1350 
1351   _impl_.feature_.Clear();
1352   _internal_metadata_.Clear<std::string>();
1353 }
1354 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1355 const char* FeatureList::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1356 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1357   while (!ctx->Done(&ptr)) {
1358     ::uint32_t tag;
1359     ptr = ::_pbi::ReadTag(ptr, &tag);
1360     switch (tag >> 3) {
1361       // repeated .tensorflow.Feature feature = 1;
1362       case 1:
1363         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1364           ptr -= 1;
1365           do {
1366             ptr += 1;
1367             ptr = ctx->ParseMessage(_internal_add_feature(), ptr);
1368             CHK_(ptr);
1369             if (!ctx->DataAvailable(ptr)) break;
1370           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1371         } else {
1372           goto handle_unusual;
1373         }
1374         continue;
1375       default:
1376         goto handle_unusual;
1377     }  // switch
1378   handle_unusual:
1379     if ((tag == 0) || ((tag & 7) == 4)) {
1380       CHK_(ptr);
1381       ctx->SetLastTag(tag);
1382       goto message_done;
1383     }
1384     ptr = UnknownFieldParse(
1385         tag,
1386         _internal_metadata_.mutable_unknown_fields<std::string>(),
1387         ptr, ctx);
1388     CHK_(ptr != nullptr);
1389   }  // while
1390 message_done:
1391   return ptr;
1392 failure:
1393   ptr = nullptr;
1394   goto message_done;
1395 #undef CHK_
1396 }
1397 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1398 ::uint8_t* FeatureList::_InternalSerialize(
1399     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1400   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FeatureList)
1401   ::uint32_t cached_has_bits = 0;
1402   (void) cached_has_bits;
1403 
1404   // repeated .tensorflow.Feature feature = 1;
1405   for (unsigned i = 0,
1406       n = static_cast<unsigned>(this->_internal_feature_size()); i < n; i++) {
1407     const auto& repfield = this->_internal_feature(i);
1408     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1409         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1410   }
1411 
1412   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1413     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1414         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1415   }
1416   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FeatureList)
1417   return target;
1418 }
1419 
ByteSizeLong() const1420 size_t FeatureList::ByteSizeLong() const {
1421 // @@protoc_insertion_point(message_byte_size_start:tensorflow.FeatureList)
1422   size_t total_size = 0;
1423 
1424   ::uint32_t cached_has_bits = 0;
1425   // Prevent compiler warnings about cached_has_bits being unused
1426   (void) cached_has_bits;
1427 
1428   // repeated .tensorflow.Feature feature = 1;
1429   total_size += 1UL * this->_internal_feature_size();
1430   for (const auto& msg : this->_impl_.feature_) {
1431     total_size +=
1432       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1433   }
1434 
1435   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1436     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1437   }
1438   int cached_size = ::_pbi::ToCachedSize(total_size);
1439   SetCachedSize(cached_size);
1440   return total_size;
1441 }
1442 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1443 void FeatureList::CheckTypeAndMergeFrom(
1444     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1445   MergeFrom(*::_pbi::DownCast<const FeatureList*>(
1446       &from));
1447 }
1448 
MergeFrom(const FeatureList & from)1449 void FeatureList::MergeFrom(const FeatureList& from) {
1450   FeatureList* const _this = this;
1451   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FeatureList)
1452   GOOGLE_DCHECK_NE(&from, _this);
1453   ::uint32_t cached_has_bits = 0;
1454   (void) cached_has_bits;
1455 
1456   _this->_impl_.feature_.MergeFrom(from._impl_.feature_);
1457   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1458 }
1459 
CopyFrom(const FeatureList & from)1460 void FeatureList::CopyFrom(const FeatureList& from) {
1461 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FeatureList)
1462   if (&from == this) return;
1463   Clear();
1464   MergeFrom(from);
1465 }
1466 
IsInitialized() const1467 bool FeatureList::IsInitialized() const {
1468   return true;
1469 }
1470 
InternalSwap(FeatureList * other)1471 void FeatureList::InternalSwap(FeatureList* other) {
1472   using std::swap;
1473   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1474   _impl_.feature_.InternalSwap(&other->_impl_.feature_);
1475 }
1476 
GetTypeName() const1477 std::string FeatureList::GetTypeName() const {
1478   return "tensorflow.FeatureList";
1479 }
1480 
1481 
1482 // ===================================================================
1483 
FeatureLists_FeatureListEntry_DoNotUse()1484 FeatureLists_FeatureListEntry_DoNotUse::FeatureLists_FeatureListEntry_DoNotUse() {}
FeatureLists_FeatureListEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)1485 FeatureLists_FeatureListEntry_DoNotUse::FeatureLists_FeatureListEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
1486     : SuperType(arena) {}
MergeFrom(const FeatureLists_FeatureListEntry_DoNotUse & other)1487 void FeatureLists_FeatureListEntry_DoNotUse::MergeFrom(const FeatureLists_FeatureListEntry_DoNotUse& other) {
1488   MergeFromInternal(other);
1489 }
1490 
1491 // ===================================================================
1492 
1493 class FeatureLists::_Internal {
1494  public:
1495 };
1496 
FeatureLists(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1497 FeatureLists::FeatureLists(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1498                          bool is_message_owned)
1499   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1500   SharedCtor(arena, is_message_owned);
1501   // @@protoc_insertion_point(arena_constructor:tensorflow.FeatureLists)
1502 }
FeatureLists(const FeatureLists & from)1503 FeatureLists::FeatureLists(const FeatureLists& from)
1504   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1505   FeatureLists* const _this = this; (void)_this;
1506   new (&_impl_) Impl_{
1507       /*decltype(_impl_.feature_list_)*/{}
1508     , /*decltype(_impl_._cached_size_)*/{}};
1509 
1510   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1511   _this->_impl_.feature_list_.MergeFrom(from._impl_.feature_list_);
1512   // @@protoc_insertion_point(copy_constructor:tensorflow.FeatureLists)
1513 }
1514 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1515 inline void FeatureLists::SharedCtor(
1516     ::_pb::Arena* arena, bool is_message_owned) {
1517   (void)arena;
1518   (void)is_message_owned;
1519   new (&_impl_) Impl_{
1520       /*decltype(_impl_.feature_list_)*/{::_pbi::ArenaInitialized(), arena}
1521     , /*decltype(_impl_._cached_size_)*/{}
1522   };
1523 }
1524 
~FeatureLists()1525 FeatureLists::~FeatureLists() {
1526   // @@protoc_insertion_point(destructor:tensorflow.FeatureLists)
1527   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1528   (void)arena;
1529     return;
1530   }
1531   SharedDtor();
1532 }
1533 
SharedDtor()1534 inline void FeatureLists::SharedDtor() {
1535   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1536   _impl_.feature_list_.Destruct();
1537   _impl_.feature_list_.~MapFieldLite();
1538 }
1539 
SetCachedSize(int size) const1540 void FeatureLists::SetCachedSize(int size) const {
1541   _impl_._cached_size_.Set(size);
1542 }
1543 
Clear()1544 void FeatureLists::Clear() {
1545 // @@protoc_insertion_point(message_clear_start:tensorflow.FeatureLists)
1546   ::uint32_t cached_has_bits = 0;
1547   // Prevent compiler warnings about cached_has_bits being unused
1548   (void) cached_has_bits;
1549 
1550   _impl_.feature_list_.Clear();
1551   _internal_metadata_.Clear<std::string>();
1552 }
1553 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1554 const char* FeatureLists::_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       // map<string, .tensorflow.FeatureList> feature_list = 1;
1561       case 1:
1562         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1563           ptr -= 1;
1564           do {
1565             ptr += 1;
1566             ptr = ctx->ParseMessage(&_impl_.feature_list_, ptr);
1567             CHK_(ptr);
1568             if (!ctx->DataAvailable(ptr)) break;
1569           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1570         } else {
1571           goto handle_unusual;
1572         }
1573         continue;
1574       default:
1575         goto handle_unusual;
1576     }  // switch
1577   handle_unusual:
1578     if ((tag == 0) || ((tag & 7) == 4)) {
1579       CHK_(ptr);
1580       ctx->SetLastTag(tag);
1581       goto message_done;
1582     }
1583     ptr = UnknownFieldParse(
1584         tag,
1585         _internal_metadata_.mutable_unknown_fields<std::string>(),
1586         ptr, ctx);
1587     CHK_(ptr != nullptr);
1588   }  // while
1589 message_done:
1590   return ptr;
1591 failure:
1592   ptr = nullptr;
1593   goto message_done;
1594 #undef CHK_
1595 }
1596 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1597 ::uint8_t* FeatureLists::_InternalSerialize(
1598     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1599   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.FeatureLists)
1600   ::uint32_t cached_has_bits = 0;
1601   (void) cached_has_bits;
1602 
1603   // map<string, .tensorflow.FeatureList> feature_list = 1;
1604   if (!this->_internal_feature_list().empty()) {
1605     using MapType = ::_pb::Map<std::string, ::tensorflow::FeatureList>;
1606     using WireHelper = FeatureLists_FeatureListEntry_DoNotUse::Funcs;
1607     const auto& map_field = this->_internal_feature_list();
1608     auto check_utf8 = [](const MapType::value_type& entry) {
1609       (void)entry;
1610       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1611         entry.first.data(), static_cast<int>(entry.first.length()),
1612         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1613         "tensorflow.FeatureLists.FeatureListEntry.key");
1614     };
1615 
1616     if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
1617       for (const auto& entry : ::_pbi::MapSorterPtr<MapType>(map_field)) {
1618         target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
1619         check_utf8(entry);
1620       }
1621     } else {
1622       for (const auto& entry : map_field) {
1623         target = WireHelper::InternalSerialize(1, entry.first, entry.second, target, stream);
1624         check_utf8(entry);
1625       }
1626     }
1627   }
1628 
1629   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1630     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1631         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1632   }
1633   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.FeatureLists)
1634   return target;
1635 }
1636 
ByteSizeLong() const1637 size_t FeatureLists::ByteSizeLong() const {
1638 // @@protoc_insertion_point(message_byte_size_start:tensorflow.FeatureLists)
1639   size_t total_size = 0;
1640 
1641   ::uint32_t cached_has_bits = 0;
1642   // Prevent compiler warnings about cached_has_bits being unused
1643   (void) cached_has_bits;
1644 
1645   // map<string, .tensorflow.FeatureList> feature_list = 1;
1646   total_size += 1 *
1647       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_feature_list_size());
1648   for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::FeatureList >::const_iterator
1649       it = this->_internal_feature_list().begin();
1650       it != this->_internal_feature_list().end(); ++it) {
1651     total_size += FeatureLists_FeatureListEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
1652   }
1653 
1654   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1655     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1656   }
1657   int cached_size = ::_pbi::ToCachedSize(total_size);
1658   SetCachedSize(cached_size);
1659   return total_size;
1660 }
1661 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1662 void FeatureLists::CheckTypeAndMergeFrom(
1663     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1664   MergeFrom(*::_pbi::DownCast<const FeatureLists*>(
1665       &from));
1666 }
1667 
MergeFrom(const FeatureLists & from)1668 void FeatureLists::MergeFrom(const FeatureLists& from) {
1669   FeatureLists* const _this = this;
1670   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.FeatureLists)
1671   GOOGLE_DCHECK_NE(&from, _this);
1672   ::uint32_t cached_has_bits = 0;
1673   (void) cached_has_bits;
1674 
1675   _this->_impl_.feature_list_.MergeFrom(from._impl_.feature_list_);
1676   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1677 }
1678 
CopyFrom(const FeatureLists & from)1679 void FeatureLists::CopyFrom(const FeatureLists& from) {
1680 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.FeatureLists)
1681   if (&from == this) return;
1682   Clear();
1683   MergeFrom(from);
1684 }
1685 
IsInitialized() const1686 bool FeatureLists::IsInitialized() const {
1687   return true;
1688 }
1689 
InternalSwap(FeatureLists * other)1690 void FeatureLists::InternalSwap(FeatureLists* other) {
1691   using std::swap;
1692   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1693   _impl_.feature_list_.InternalSwap(&other->_impl_.feature_list_);
1694 }
1695 
GetTypeName() const1696 std::string FeatureLists::GetTypeName() const {
1697   return "tensorflow.FeatureLists";
1698 }
1699 
1700 
1701 // @@protoc_insertion_point(namespace_scope)
1702 }  // namespace tensorflow
1703 PROTOBUF_NAMESPACE_OPEN
1704 template<> PROTOBUF_NOINLINE ::tensorflow::BytesList*
CreateMaybeMessage(Arena * arena)1705 Arena::CreateMaybeMessage< ::tensorflow::BytesList >(Arena* arena) {
1706   return Arena::CreateMessageInternal< ::tensorflow::BytesList >(arena);
1707 }
1708 template<> PROTOBUF_NOINLINE ::tensorflow::FloatList*
CreateMaybeMessage(Arena * arena)1709 Arena::CreateMaybeMessage< ::tensorflow::FloatList >(Arena* arena) {
1710   return Arena::CreateMessageInternal< ::tensorflow::FloatList >(arena);
1711 }
1712 template<> PROTOBUF_NOINLINE ::tensorflow::Int64List*
CreateMaybeMessage(Arena * arena)1713 Arena::CreateMaybeMessage< ::tensorflow::Int64List >(Arena* arena) {
1714   return Arena::CreateMessageInternal< ::tensorflow::Int64List >(arena);
1715 }
1716 template<> PROTOBUF_NOINLINE ::tensorflow::Feature*
CreateMaybeMessage(Arena * arena)1717 Arena::CreateMaybeMessage< ::tensorflow::Feature >(Arena* arena) {
1718   return Arena::CreateMessageInternal< ::tensorflow::Feature >(arena);
1719 }
1720 template<> PROTOBUF_NOINLINE ::tensorflow::Features_FeatureEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)1721 Arena::CreateMaybeMessage< ::tensorflow::Features_FeatureEntry_DoNotUse >(Arena* arena) {
1722   return Arena::CreateMessageInternal< ::tensorflow::Features_FeatureEntry_DoNotUse >(arena);
1723 }
1724 template<> PROTOBUF_NOINLINE ::tensorflow::Features*
CreateMaybeMessage(Arena * arena)1725 Arena::CreateMaybeMessage< ::tensorflow::Features >(Arena* arena) {
1726   return Arena::CreateMessageInternal< ::tensorflow::Features >(arena);
1727 }
1728 template<> PROTOBUF_NOINLINE ::tensorflow::FeatureList*
CreateMaybeMessage(Arena * arena)1729 Arena::CreateMaybeMessage< ::tensorflow::FeatureList >(Arena* arena) {
1730   return Arena::CreateMessageInternal< ::tensorflow::FeatureList >(arena);
1731 }
1732 template<> PROTOBUF_NOINLINE ::tensorflow::FeatureLists_FeatureListEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)1733 Arena::CreateMaybeMessage< ::tensorflow::FeatureLists_FeatureListEntry_DoNotUse >(Arena* arena) {
1734   return Arena::CreateMessageInternal< ::tensorflow::FeatureLists_FeatureListEntry_DoNotUse >(arena);
1735 }
1736 template<> PROTOBUF_NOINLINE ::tensorflow::FeatureLists*
CreateMaybeMessage(Arena * arena)1737 Arena::CreateMaybeMessage< ::tensorflow::FeatureLists >(Arena* arena) {
1738   return Arena::CreateMessageInternal< ::tensorflow::FeatureLists >(arena);
1739 }
1740 PROTOBUF_NAMESPACE_CLOSE
1741 
1742 // @@protoc_insertion_point(global_scope)
1743 #include <google/protobuf/port_undef.inc>
1744