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