1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/struct.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/map.h> // IWYU pragma: export
35#include <google/protobuf/map_entry.h>
36#include <google/protobuf/map_field_inl.h>
37#include <google/protobuf/generated_enum_reflection.h>
38#include <google/protobuf/unknown_field_set.h>
39#include "tensorflow/core/framework/tensor.pb.h"
40#include "tensorflow/core/framework/tensor_shape.pb.h"
41#include "tensorflow/core/framework/types.pb.h"
42// @@protoc_insertion_point(includes)
43#include <google/protobuf/port_def.inc>
44#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto
45PROTOBUF_NAMESPACE_OPEN
46namespace internal {
47class AnyMetadata;
48} // namespace internal
49PROTOBUF_NAMESPACE_CLOSE
50
51// Internal implementation detail -- do not use these members.
52struct TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto {
53 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
54 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
55 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
56 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
57 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
58 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
59 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
60 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
61 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
62};
63extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
64namespace tensorflow {
65class BoundedTensorSpecProto;
66class BoundedTensorSpecProtoDefaultTypeInternal;
67extern BoundedTensorSpecProtoDefaultTypeInternal _BoundedTensorSpecProto_default_instance_;
68class DictValue;
69class DictValueDefaultTypeInternal;
70extern DictValueDefaultTypeInternal _DictValue_default_instance_;
71class DictValue_FieldsEntry_DoNotUse;
72class DictValue_FieldsEntry_DoNotUseDefaultTypeInternal;
73extern DictValue_FieldsEntry_DoNotUseDefaultTypeInternal _DictValue_FieldsEntry_DoNotUse_default_instance_;
74class ListValue;
75class ListValueDefaultTypeInternal;
76extern ListValueDefaultTypeInternal _ListValue_default_instance_;
77class NamedTupleValue;
78class NamedTupleValueDefaultTypeInternal;
79extern NamedTupleValueDefaultTypeInternal _NamedTupleValue_default_instance_;
80class NoneValue;
81class NoneValueDefaultTypeInternal;
82extern NoneValueDefaultTypeInternal _NoneValue_default_instance_;
83class PairValue;
84class PairValueDefaultTypeInternal;
85extern PairValueDefaultTypeInternal _PairValue_default_instance_;
86class StructuredValue;
87class StructuredValueDefaultTypeInternal;
88extern StructuredValueDefaultTypeInternal _StructuredValue_default_instance_;
89class TensorSpecProto;
90class TensorSpecProtoDefaultTypeInternal;
91extern TensorSpecProtoDefaultTypeInternal _TensorSpecProto_default_instance_;
92class TupleValue;
93class TupleValueDefaultTypeInternal;
94extern TupleValueDefaultTypeInternal _TupleValue_default_instance_;
95class TypeSpecProto;
96class TypeSpecProtoDefaultTypeInternal;
97extern TypeSpecProtoDefaultTypeInternal _TypeSpecProto_default_instance_;
98} // namespace tensorflow
99PROTOBUF_NAMESPACE_OPEN
100template<> ::tensorflow::BoundedTensorSpecProto* Arena::CreateMaybeMessage<::tensorflow::BoundedTensorSpecProto>(Arena*);
101template<> ::tensorflow::DictValue* Arena::CreateMaybeMessage<::tensorflow::DictValue>(Arena*);
102template<> ::tensorflow::DictValue_FieldsEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::DictValue_FieldsEntry_DoNotUse>(Arena*);
103template<> ::tensorflow::ListValue* Arena::CreateMaybeMessage<::tensorflow::ListValue>(Arena*);
104template<> ::tensorflow::NamedTupleValue* Arena::CreateMaybeMessage<::tensorflow::NamedTupleValue>(Arena*);
105template<> ::tensorflow::NoneValue* Arena::CreateMaybeMessage<::tensorflow::NoneValue>(Arena*);
106template<> ::tensorflow::PairValue* Arena::CreateMaybeMessage<::tensorflow::PairValue>(Arena*);
107template<> ::tensorflow::StructuredValue* Arena::CreateMaybeMessage<::tensorflow::StructuredValue>(Arena*);
108template<> ::tensorflow::TensorSpecProto* Arena::CreateMaybeMessage<::tensorflow::TensorSpecProto>(Arena*);
109template<> ::tensorflow::TupleValue* Arena::CreateMaybeMessage<::tensorflow::TupleValue>(Arena*);
110template<> ::tensorflow::TypeSpecProto* Arena::CreateMaybeMessage<::tensorflow::TypeSpecProto>(Arena*);
111PROTOBUF_NAMESPACE_CLOSE
112namespace tensorflow {
113
114enum TypeSpecProto_TypeSpecClass : int {
115 TypeSpecProto_TypeSpecClass_UNKNOWN = 0,
116 TypeSpecProto_TypeSpecClass_SPARSE_TENSOR_SPEC = 1,
117 TypeSpecProto_TypeSpecClass_INDEXED_SLICES_SPEC = 2,
118 TypeSpecProto_TypeSpecClass_RAGGED_TENSOR_SPEC = 3,
119 TypeSpecProto_TypeSpecClass_TENSOR_ARRAY_SPEC = 4,
120 TypeSpecProto_TypeSpecClass_DATA_DATASET_SPEC = 5,
121 TypeSpecProto_TypeSpecClass_DATA_ITERATOR_SPEC = 6,
122 TypeSpecProto_TypeSpecClass_OPTIONAL_SPEC = 7,
123 TypeSpecProto_TypeSpecClass_PER_REPLICA_SPEC = 8,
124 TypeSpecProto_TypeSpecClass_VARIABLE_SPEC = 9,
125 TypeSpecProto_TypeSpecClass_ROW_PARTITION_SPEC = 10,
126 TypeSpecProto_TypeSpecClass_REGISTERED_TYPE_SPEC = 12,
127 TypeSpecProto_TypeSpecClass_EXTENSION_TYPE_SPEC = 13,
128 TypeSpecProto_TypeSpecClass_TypeSpecProto_TypeSpecClass_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
129 TypeSpecProto_TypeSpecClass_TypeSpecProto_TypeSpecClass_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
130};
131bool TypeSpecProto_TypeSpecClass_IsValid(int value);
132constexpr TypeSpecProto_TypeSpecClass TypeSpecProto_TypeSpecClass_TypeSpecClass_MIN = TypeSpecProto_TypeSpecClass_UNKNOWN;
133constexpr TypeSpecProto_TypeSpecClass TypeSpecProto_TypeSpecClass_TypeSpecClass_MAX = TypeSpecProto_TypeSpecClass_EXTENSION_TYPE_SPEC;
134constexpr int TypeSpecProto_TypeSpecClass_TypeSpecClass_ARRAYSIZE = TypeSpecProto_TypeSpecClass_TypeSpecClass_MAX + 1;
135
136const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TypeSpecProto_TypeSpecClass_descriptor();
137template<typename T>
138inline const std::string& TypeSpecProto_TypeSpecClass_Name(T enum_t_value) {
139 static_assert(::std::is_same<T, TypeSpecProto_TypeSpecClass>::value ||
140 ::std::is_integral<T>::value,
141 "Incorrect type passed to function TypeSpecProto_TypeSpecClass_Name.");
142 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
143 TypeSpecProto_TypeSpecClass_descriptor(), enum_t_value);
144}
145inline bool TypeSpecProto_TypeSpecClass_Parse(
146 const std::string& name, TypeSpecProto_TypeSpecClass* value) {
147 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TypeSpecProto_TypeSpecClass>(
148 TypeSpecProto_TypeSpecClass_descriptor(), name, value);
149}
150// ===================================================================
151
152class StructuredValue :
153 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.StructuredValue) */ {
154 public:
155 StructuredValue();
156 virtual ~StructuredValue();
157
158 StructuredValue(const StructuredValue& from);
159 StructuredValue(StructuredValue&& from) noexcept
160 : StructuredValue() {
161 *this = ::std::move(from);
162 }
163
164 inline StructuredValue& operator=(const StructuredValue& from) {
165 CopyFrom(from);
166 return *this;
167 }
168 inline StructuredValue& operator=(StructuredValue&& from) noexcept {
169 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
170 if (this != &from) InternalSwap(&from);
171 } else {
172 CopyFrom(from);
173 }
174 return *this;
175 }
176
177 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
178 return GetDescriptor();
179 }
180 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
181 return GetMetadataStatic().descriptor;
182 }
183 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
184 return GetMetadataStatic().reflection;
185 }
186 static const StructuredValue& default_instance();
187
188 enum KindCase {
189 kNoneValue = 1,
190 kFloat64Value = 11,
191 kInt64Value = 12,
192 kStringValue = 13,
193 kBoolValue = 14,
194 kTensorShapeValue = 31,
195 kTensorDtypeValue = 32,
196 kTensorSpecValue = 33,
197 kTypeSpecValue = 34,
198 kBoundedTensorSpecValue = 35,
199 kListValue = 51,
200 kTupleValue = 52,
201 kDictValue = 53,
202 kNamedTupleValue = 54,
203 KIND_NOT_SET = 0,
204 };
205
206 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
207 static inline const StructuredValue* internal_default_instance() {
208 return reinterpret_cast<const StructuredValue*>(
209 &_StructuredValue_default_instance_);
210 }
211 static constexpr int kIndexInFileMessages =
212 0;
213
214 friend void swap(StructuredValue& a, StructuredValue& b) {
215 a.Swap(&b);
216 }
217 inline void Swap(StructuredValue* other) {
218 if (other == this) return;
219 InternalSwap(other);
220 }
221
222 // implements Message ----------------------------------------------
223
224 inline StructuredValue* New() const final {
225 return CreateMaybeMessage<StructuredValue>(nullptr);
226 }
227
228 StructuredValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
229 return CreateMaybeMessage<StructuredValue>(arena);
230 }
231 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
232 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
233 void CopyFrom(const StructuredValue& from);
234 void MergeFrom(const StructuredValue& from);
235 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
236 bool IsInitialized() const final;
237
238 size_t ByteSizeLong() const final;
239 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
240 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
241 #else
242 bool MergePartialFromCodedStream(
243 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
244 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
245 void SerializeWithCachedSizes(
246 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
247 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
248 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
249 int GetCachedSize() const final { return _cached_size_.Get(); }
250
251 private:
252 inline void SharedCtor();
253 inline void SharedDtor();
254 void SetCachedSize(int size) const final;
255 void InternalSwap(StructuredValue* other);
256 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
257 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
258 return "tensorflow.StructuredValue";
259 }
260 private:
261 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
262 return nullptr;
263 }
264 inline void* MaybeArenaPtr() const {
265 return nullptr;
266 }
267 public:
268
269 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
270 private:
271 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
272 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
273 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
274 }
275
276 public:
277
278 // nested types ----------------------------------------------------
279
280 // accessors -------------------------------------------------------
281
282 enum : int {
283 kNoneValueFieldNumber = 1,
284 kFloat64ValueFieldNumber = 11,
285 kInt64ValueFieldNumber = 12,
286 kStringValueFieldNumber = 13,
287 kBoolValueFieldNumber = 14,
288 kTensorShapeValueFieldNumber = 31,
289 kTensorDtypeValueFieldNumber = 32,
290 kTensorSpecValueFieldNumber = 33,
291 kTypeSpecValueFieldNumber = 34,
292 kBoundedTensorSpecValueFieldNumber = 35,
293 kListValueFieldNumber = 51,
294 kTupleValueFieldNumber = 52,
295 kDictValueFieldNumber = 53,
296 kNamedTupleValueFieldNumber = 54,
297 };
298 // .tensorflow.NoneValue none_value = 1;
299 bool has_none_value() const;
300 void clear_none_value();
301 const ::tensorflow::NoneValue& none_value() const;
302 ::tensorflow::NoneValue* release_none_value();
303 ::tensorflow::NoneValue* mutable_none_value();
304 void set_allocated_none_value(::tensorflow::NoneValue* none_value);
305
306 // double float64_value = 11;
307 private:
308 bool has_float64_value() const;
309 public:
310 void clear_float64_value();
311 double float64_value() const;
312 void set_float64_value(double value);
313
314 // sint64 int64_value = 12;
315 private:
316 bool has_int64_value() const;
317 public:
318 void clear_int64_value();
319 ::PROTOBUF_NAMESPACE_ID::int64 int64_value() const;
320 void set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value);
321
322 // string string_value = 13;
323 private:
324 bool has_string_value() const;
325 public:
326 void clear_string_value();
327 const std::string& string_value() const;
328 void set_string_value(const std::string& value);
329 void set_string_value(std::string&& value);
330 void set_string_value(const char* value);
331 void set_string_value(const char* value, size_t size);
332 std::string* mutable_string_value();
333 std::string* release_string_value();
334 void set_allocated_string_value(std::string* string_value);
335
336 // bool bool_value = 14;
337 private:
338 bool has_bool_value() const;
339 public:
340 void clear_bool_value();
341 bool bool_value() const;
342 void set_bool_value(bool value);
343
344 // .tensorflow.TensorShapeProto tensor_shape_value = 31;
345 bool has_tensor_shape_value() const;
346 void clear_tensor_shape_value();
347 const ::tensorflow::TensorShapeProto& tensor_shape_value() const;
348 ::tensorflow::TensorShapeProto* release_tensor_shape_value();
349 ::tensorflow::TensorShapeProto* mutable_tensor_shape_value();
350 void set_allocated_tensor_shape_value(::tensorflow::TensorShapeProto* tensor_shape_value);
351
352 // .tensorflow.DataType tensor_dtype_value = 32;
353 private:
354 bool has_tensor_dtype_value() const;
355 public:
356 void clear_tensor_dtype_value();
357 ::tensorflow::DataType tensor_dtype_value() const;
358 void set_tensor_dtype_value(::tensorflow::DataType value);
359
360 // .tensorflow.TensorSpecProto tensor_spec_value = 33;
361 bool has_tensor_spec_value() const;
362 void clear_tensor_spec_value();
363 const ::tensorflow::TensorSpecProto& tensor_spec_value() const;
364 ::tensorflow::TensorSpecProto* release_tensor_spec_value();
365 ::tensorflow::TensorSpecProto* mutable_tensor_spec_value();
366 void set_allocated_tensor_spec_value(::tensorflow::TensorSpecProto* tensor_spec_value);
367
368 // .tensorflow.TypeSpecProto type_spec_value = 34;
369 bool has_type_spec_value() const;
370 void clear_type_spec_value();
371 const ::tensorflow::TypeSpecProto& type_spec_value() const;
372 ::tensorflow::TypeSpecProto* release_type_spec_value();
373 ::tensorflow::TypeSpecProto* mutable_type_spec_value();
374 void set_allocated_type_spec_value(::tensorflow::TypeSpecProto* type_spec_value);
375
376 // .tensorflow.BoundedTensorSpecProto bounded_tensor_spec_value = 35;
377 bool has_bounded_tensor_spec_value() const;
378 void clear_bounded_tensor_spec_value();
379 const ::tensorflow::BoundedTensorSpecProto& bounded_tensor_spec_value() const;
380 ::tensorflow::BoundedTensorSpecProto* release_bounded_tensor_spec_value();
381 ::tensorflow::BoundedTensorSpecProto* mutable_bounded_tensor_spec_value();
382 void set_allocated_bounded_tensor_spec_value(::tensorflow::BoundedTensorSpecProto* bounded_tensor_spec_value);
383
384 // .tensorflow.ListValue list_value = 51;
385 bool has_list_value() const;
386 void clear_list_value();
387 const ::tensorflow::ListValue& list_value() const;
388 ::tensorflow::ListValue* release_list_value();
389 ::tensorflow::ListValue* mutable_list_value();
390 void set_allocated_list_value(::tensorflow::ListValue* list_value);
391
392 // .tensorflow.TupleValue tuple_value = 52;
393 bool has_tuple_value() const;
394 void clear_tuple_value();
395 const ::tensorflow::TupleValue& tuple_value() const;
396 ::tensorflow::TupleValue* release_tuple_value();
397 ::tensorflow::TupleValue* mutable_tuple_value();
398 void set_allocated_tuple_value(::tensorflow::TupleValue* tuple_value);
399
400 // .tensorflow.DictValue dict_value = 53;
401 bool has_dict_value() const;
402 void clear_dict_value();
403 const ::tensorflow::DictValue& dict_value() const;
404 ::tensorflow::DictValue* release_dict_value();
405 ::tensorflow::DictValue* mutable_dict_value();
406 void set_allocated_dict_value(::tensorflow::DictValue* dict_value);
407
408 // .tensorflow.NamedTupleValue named_tuple_value = 54;
409 bool has_named_tuple_value() const;
410 void clear_named_tuple_value();
411 const ::tensorflow::NamedTupleValue& named_tuple_value() const;
412 ::tensorflow::NamedTupleValue* release_named_tuple_value();
413 ::tensorflow::NamedTupleValue* mutable_named_tuple_value();
414 void set_allocated_named_tuple_value(::tensorflow::NamedTupleValue* named_tuple_value);
415
416 void clear_kind();
417 KindCase kind_case() const;
418 // @@protoc_insertion_point(class_scope:tensorflow.StructuredValue)
419 private:
420 class _Internal;
421 void set_has_none_value();
422 void set_has_float64_value();
423 void set_has_int64_value();
424 void set_has_string_value();
425 void set_has_bool_value();
426 void set_has_tensor_shape_value();
427 void set_has_tensor_dtype_value();
428 void set_has_tensor_spec_value();
429 void set_has_type_spec_value();
430 void set_has_bounded_tensor_spec_value();
431 void set_has_list_value();
432 void set_has_tuple_value();
433 void set_has_dict_value();
434 void set_has_named_tuple_value();
435
436 inline bool has_kind() const;
437 inline void clear_has_kind();
438
439 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
440 union KindUnion {
441 KindUnion() {}
442 ::tensorflow::NoneValue* none_value_;
443 double float64_value_;
444 ::PROTOBUF_NAMESPACE_ID::int64 int64_value_;
445 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
446 bool bool_value_;
447 ::tensorflow::TensorShapeProto* tensor_shape_value_;
448 int tensor_dtype_value_;
449 ::tensorflow::TensorSpecProto* tensor_spec_value_;
450 ::tensorflow::TypeSpecProto* type_spec_value_;
451 ::tensorflow::BoundedTensorSpecProto* bounded_tensor_spec_value_;
452 ::tensorflow::ListValue* list_value_;
453 ::tensorflow::TupleValue* tuple_value_;
454 ::tensorflow::DictValue* dict_value_;
455 ::tensorflow::NamedTupleValue* named_tuple_value_;
456 } kind_;
457 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
458 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
459
460 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
461};
462// -------------------------------------------------------------------
463
464class NoneValue :
465 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NoneValue) */ {
466 public:
467 NoneValue();
468 virtual ~NoneValue();
469
470 NoneValue(const NoneValue& from);
471 NoneValue(NoneValue&& from) noexcept
472 : NoneValue() {
473 *this = ::std::move(from);
474 }
475
476 inline NoneValue& operator=(const NoneValue& from) {
477 CopyFrom(from);
478 return *this;
479 }
480 inline NoneValue& operator=(NoneValue&& from) noexcept {
481 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
482 if (this != &from) InternalSwap(&from);
483 } else {
484 CopyFrom(from);
485 }
486 return *this;
487 }
488
489 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
490 return GetDescriptor();
491 }
492 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
493 return GetMetadataStatic().descriptor;
494 }
495 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
496 return GetMetadataStatic().reflection;
497 }
498 static const NoneValue& default_instance();
499
500 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
501 static inline const NoneValue* internal_default_instance() {
502 return reinterpret_cast<const NoneValue*>(
503 &_NoneValue_default_instance_);
504 }
505 static constexpr int kIndexInFileMessages =
506 1;
507
508 friend void swap(NoneValue& a, NoneValue& b) {
509 a.Swap(&b);
510 }
511 inline void Swap(NoneValue* other) {
512 if (other == this) return;
513 InternalSwap(other);
514 }
515
516 // implements Message ----------------------------------------------
517
518 inline NoneValue* New() const final {
519 return CreateMaybeMessage<NoneValue>(nullptr);
520 }
521
522 NoneValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
523 return CreateMaybeMessage<NoneValue>(arena);
524 }
525 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
526 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
527 void CopyFrom(const NoneValue& from);
528 void MergeFrom(const NoneValue& from);
529 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
530 bool IsInitialized() const final;
531
532 size_t ByteSizeLong() const final;
533 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
534 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
535 #else
536 bool MergePartialFromCodedStream(
537 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
538 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
539 void SerializeWithCachedSizes(
540 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
541 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
542 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
543 int GetCachedSize() const final { return _cached_size_.Get(); }
544
545 private:
546 inline void SharedCtor();
547 inline void SharedDtor();
548 void SetCachedSize(int size) const final;
549 void InternalSwap(NoneValue* other);
550 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
551 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
552 return "tensorflow.NoneValue";
553 }
554 private:
555 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
556 return nullptr;
557 }
558 inline void* MaybeArenaPtr() const {
559 return nullptr;
560 }
561 public:
562
563 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
564 private:
565 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
566 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
567 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
568 }
569
570 public:
571
572 // nested types ----------------------------------------------------
573
574 // accessors -------------------------------------------------------
575
576 // @@protoc_insertion_point(class_scope:tensorflow.NoneValue)
577 private:
578 class _Internal;
579
580 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
581 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
582 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
583};
584// -------------------------------------------------------------------
585
586class ListValue :
587 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ListValue) */ {
588 public:
589 ListValue();
590 virtual ~ListValue();
591
592 ListValue(const ListValue& from);
593 ListValue(ListValue&& from) noexcept
594 : ListValue() {
595 *this = ::std::move(from);
596 }
597
598 inline ListValue& operator=(const ListValue& from) {
599 CopyFrom(from);
600 return *this;
601 }
602 inline ListValue& operator=(ListValue&& from) noexcept {
603 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
604 if (this != &from) InternalSwap(&from);
605 } else {
606 CopyFrom(from);
607 }
608 return *this;
609 }
610
611 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
612 return GetDescriptor();
613 }
614 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
615 return GetMetadataStatic().descriptor;
616 }
617 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
618 return GetMetadataStatic().reflection;
619 }
620 static const ListValue& default_instance();
621
622 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
623 static inline const ListValue* internal_default_instance() {
624 return reinterpret_cast<const ListValue*>(
625 &_ListValue_default_instance_);
626 }
627 static constexpr int kIndexInFileMessages =
628 2;
629
630 friend void swap(ListValue& a, ListValue& b) {
631 a.Swap(&b);
632 }
633 inline void Swap(ListValue* other) {
634 if (other == this) return;
635 InternalSwap(other);
636 }
637
638 // implements Message ----------------------------------------------
639
640 inline ListValue* New() const final {
641 return CreateMaybeMessage<ListValue>(nullptr);
642 }
643
644 ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
645 return CreateMaybeMessage<ListValue>(arena);
646 }
647 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
648 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
649 void CopyFrom(const ListValue& from);
650 void MergeFrom(const ListValue& from);
651 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
652 bool IsInitialized() const final;
653
654 size_t ByteSizeLong() const final;
655 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
656 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
657 #else
658 bool MergePartialFromCodedStream(
659 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
660 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
661 void SerializeWithCachedSizes(
662 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
663 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
664 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
665 int GetCachedSize() const final { return _cached_size_.Get(); }
666
667 private:
668 inline void SharedCtor();
669 inline void SharedDtor();
670 void SetCachedSize(int size) const final;
671 void InternalSwap(ListValue* other);
672 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
673 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
674 return "tensorflow.ListValue";
675 }
676 private:
677 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
678 return nullptr;
679 }
680 inline void* MaybeArenaPtr() const {
681 return nullptr;
682 }
683 public:
684
685 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
686 private:
687 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
688 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
689 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
690 }
691
692 public:
693
694 // nested types ----------------------------------------------------
695
696 // accessors -------------------------------------------------------
697
698 enum : int {
699 kValuesFieldNumber = 1,
700 };
701 // repeated .tensorflow.StructuredValue values = 1;
702 int values_size() const;
703 void clear_values();
704 ::tensorflow::StructuredValue* mutable_values(int index);
705 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >*
706 mutable_values();
707 const ::tensorflow::StructuredValue& values(int index) const;
708 ::tensorflow::StructuredValue* add_values();
709 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >&
710 values() const;
711
712 // @@protoc_insertion_point(class_scope:tensorflow.ListValue)
713 private:
714 class _Internal;
715
716 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
717 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue > values_;
718 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
719 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
720};
721// -------------------------------------------------------------------
722
723class TupleValue :
724 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TupleValue) */ {
725 public:
726 TupleValue();
727 virtual ~TupleValue();
728
729 TupleValue(const TupleValue& from);
730 TupleValue(TupleValue&& from) noexcept
731 : TupleValue() {
732 *this = ::std::move(from);
733 }
734
735 inline TupleValue& operator=(const TupleValue& from) {
736 CopyFrom(from);
737 return *this;
738 }
739 inline TupleValue& operator=(TupleValue&& from) noexcept {
740 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
741 if (this != &from) InternalSwap(&from);
742 } else {
743 CopyFrom(from);
744 }
745 return *this;
746 }
747
748 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
749 return GetDescriptor();
750 }
751 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
752 return GetMetadataStatic().descriptor;
753 }
754 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
755 return GetMetadataStatic().reflection;
756 }
757 static const TupleValue& default_instance();
758
759 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
760 static inline const TupleValue* internal_default_instance() {
761 return reinterpret_cast<const TupleValue*>(
762 &_TupleValue_default_instance_);
763 }
764 static constexpr int kIndexInFileMessages =
765 3;
766
767 friend void swap(TupleValue& a, TupleValue& b) {
768 a.Swap(&b);
769 }
770 inline void Swap(TupleValue* other) {
771 if (other == this) return;
772 InternalSwap(other);
773 }
774
775 // implements Message ----------------------------------------------
776
777 inline TupleValue* New() const final {
778 return CreateMaybeMessage<TupleValue>(nullptr);
779 }
780
781 TupleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
782 return CreateMaybeMessage<TupleValue>(arena);
783 }
784 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
785 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
786 void CopyFrom(const TupleValue& from);
787 void MergeFrom(const TupleValue& from);
788 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
789 bool IsInitialized() const final;
790
791 size_t ByteSizeLong() const final;
792 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
793 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
794 #else
795 bool MergePartialFromCodedStream(
796 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
797 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
798 void SerializeWithCachedSizes(
799 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
800 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
801 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
802 int GetCachedSize() const final { return _cached_size_.Get(); }
803
804 private:
805 inline void SharedCtor();
806 inline void SharedDtor();
807 void SetCachedSize(int size) const final;
808 void InternalSwap(TupleValue* other);
809 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
810 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
811 return "tensorflow.TupleValue";
812 }
813 private:
814 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
815 return nullptr;
816 }
817 inline void* MaybeArenaPtr() const {
818 return nullptr;
819 }
820 public:
821
822 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
823 private:
824 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
825 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
826 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
827 }
828
829 public:
830
831 // nested types ----------------------------------------------------
832
833 // accessors -------------------------------------------------------
834
835 enum : int {
836 kValuesFieldNumber = 1,
837 };
838 // repeated .tensorflow.StructuredValue values = 1;
839 int values_size() const;
840 void clear_values();
841 ::tensorflow::StructuredValue* mutable_values(int index);
842 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >*
843 mutable_values();
844 const ::tensorflow::StructuredValue& values(int index) const;
845 ::tensorflow::StructuredValue* add_values();
846 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >&
847 values() const;
848
849 // @@protoc_insertion_point(class_scope:tensorflow.TupleValue)
850 private:
851 class _Internal;
852
853 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
854 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue > values_;
855 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
856 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
857};
858// -------------------------------------------------------------------
859
860class DictValue_FieldsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DictValue_FieldsEntry_DoNotUse,
861 std::string, ::tensorflow::StructuredValue,
862 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
863 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
864 0 > {
865public:
866 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<DictValue_FieldsEntry_DoNotUse,
867 std::string, ::tensorflow::StructuredValue,
868 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
869 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
870 0 > SuperType;
871 DictValue_FieldsEntry_DoNotUse();
872 DictValue_FieldsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
873 void MergeFrom(const DictValue_FieldsEntry_DoNotUse& other);
874 static const DictValue_FieldsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const DictValue_FieldsEntry_DoNotUse*>(&_DictValue_FieldsEntry_DoNotUse_default_instance_); }
875 static bool ValidateKey(std::string* s) {
876 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.DictValue.FieldsEntry.key");
877 }
878 static bool ValidateValue(void*) { return true; }
879 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
880 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
881 private:
882 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
883 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
884 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[4];
885 }
886
887 public:
888};
889
890// -------------------------------------------------------------------
891
892class DictValue :
893 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DictValue) */ {
894 public:
895 DictValue();
896 virtual ~DictValue();
897
898 DictValue(const DictValue& from);
899 DictValue(DictValue&& from) noexcept
900 : DictValue() {
901 *this = ::std::move(from);
902 }
903
904 inline DictValue& operator=(const DictValue& from) {
905 CopyFrom(from);
906 return *this;
907 }
908 inline DictValue& operator=(DictValue&& from) noexcept {
909 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
910 if (this != &from) InternalSwap(&from);
911 } else {
912 CopyFrom(from);
913 }
914 return *this;
915 }
916
917 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
918 return GetDescriptor();
919 }
920 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
921 return GetMetadataStatic().descriptor;
922 }
923 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
924 return GetMetadataStatic().reflection;
925 }
926 static const DictValue& default_instance();
927
928 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
929 static inline const DictValue* internal_default_instance() {
930 return reinterpret_cast<const DictValue*>(
931 &_DictValue_default_instance_);
932 }
933 static constexpr int kIndexInFileMessages =
934 5;
935
936 friend void swap(DictValue& a, DictValue& b) {
937 a.Swap(&b);
938 }
939 inline void Swap(DictValue* other) {
940 if (other == this) return;
941 InternalSwap(other);
942 }
943
944 // implements Message ----------------------------------------------
945
946 inline DictValue* New() const final {
947 return CreateMaybeMessage<DictValue>(nullptr);
948 }
949
950 DictValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
951 return CreateMaybeMessage<DictValue>(arena);
952 }
953 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
954 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
955 void CopyFrom(const DictValue& from);
956 void MergeFrom(const DictValue& from);
957 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
958 bool IsInitialized() const final;
959
960 size_t ByteSizeLong() const final;
961 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
962 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
963 #else
964 bool MergePartialFromCodedStream(
965 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
966 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
967 void SerializeWithCachedSizes(
968 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
969 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
970 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
971 int GetCachedSize() const final { return _cached_size_.Get(); }
972
973 private:
974 inline void SharedCtor();
975 inline void SharedDtor();
976 void SetCachedSize(int size) const final;
977 void InternalSwap(DictValue* other);
978 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
979 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
980 return "tensorflow.DictValue";
981 }
982 private:
983 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
984 return nullptr;
985 }
986 inline void* MaybeArenaPtr() const {
987 return nullptr;
988 }
989 public:
990
991 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
992 private:
993 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
994 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
995 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
996 }
997
998 public:
999
1000 // nested types ----------------------------------------------------
1001
1002
1003 // accessors -------------------------------------------------------
1004
1005 enum : int {
1006 kFieldsFieldNumber = 1,
1007 };
1008 // map<string, .tensorflow.StructuredValue> fields = 1;
1009 int fields_size() const;
1010 void clear_fields();
1011 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::StructuredValue >&
1012 fields() const;
1013 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::StructuredValue >*
1014 mutable_fields();
1015
1016 // @@protoc_insertion_point(class_scope:tensorflow.DictValue)
1017 private:
1018 class _Internal;
1019
1020 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1021 ::PROTOBUF_NAMESPACE_ID::internal::MapField<
1022 DictValue_FieldsEntry_DoNotUse,
1023 std::string, ::tensorflow::StructuredValue,
1024 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1025 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
1026 0 > fields_;
1027 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1028 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1029};
1030// -------------------------------------------------------------------
1031
1032class PairValue :
1033 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.PairValue) */ {
1034 public:
1035 PairValue();
1036 virtual ~PairValue();
1037
1038 PairValue(const PairValue& from);
1039 PairValue(PairValue&& from) noexcept
1040 : PairValue() {
1041 *this = ::std::move(from);
1042 }
1043
1044 inline PairValue& operator=(const PairValue& from) {
1045 CopyFrom(from);
1046 return *this;
1047 }
1048 inline PairValue& operator=(PairValue&& from) noexcept {
1049 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1050 if (this != &from) InternalSwap(&from);
1051 } else {
1052 CopyFrom(from);
1053 }
1054 return *this;
1055 }
1056
1057 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1058 return GetDescriptor();
1059 }
1060 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1061 return GetMetadataStatic().descriptor;
1062 }
1063 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1064 return GetMetadataStatic().reflection;
1065 }
1066 static const PairValue& default_instance();
1067
1068 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1069 static inline const PairValue* internal_default_instance() {
1070 return reinterpret_cast<const PairValue*>(
1071 &_PairValue_default_instance_);
1072 }
1073 static constexpr int kIndexInFileMessages =
1074 6;
1075
1076 friend void swap(PairValue& a, PairValue& b) {
1077 a.Swap(&b);
1078 }
1079 inline void Swap(PairValue* other) {
1080 if (other == this) return;
1081 InternalSwap(other);
1082 }
1083
1084 // implements Message ----------------------------------------------
1085
1086 inline PairValue* New() const final {
1087 return CreateMaybeMessage<PairValue>(nullptr);
1088 }
1089
1090 PairValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1091 return CreateMaybeMessage<PairValue>(arena);
1092 }
1093 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1094 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1095 void CopyFrom(const PairValue& from);
1096 void MergeFrom(const PairValue& from);
1097 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1098 bool IsInitialized() const final;
1099
1100 size_t ByteSizeLong() const final;
1101 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1102 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1103 #else
1104 bool MergePartialFromCodedStream(
1105 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1106 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1107 void SerializeWithCachedSizes(
1108 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1109 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1110 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1111 int GetCachedSize() const final { return _cached_size_.Get(); }
1112
1113 private:
1114 inline void SharedCtor();
1115 inline void SharedDtor();
1116 void SetCachedSize(int size) const final;
1117 void InternalSwap(PairValue* other);
1118 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1119 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1120 return "tensorflow.PairValue";
1121 }
1122 private:
1123 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1124 return nullptr;
1125 }
1126 inline void* MaybeArenaPtr() const {
1127 return nullptr;
1128 }
1129 public:
1130
1131 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1132 private:
1133 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1134 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
1135 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
1136 }
1137
1138 public:
1139
1140 // nested types ----------------------------------------------------
1141
1142 // accessors -------------------------------------------------------
1143
1144 enum : int {
1145 kKeyFieldNumber = 1,
1146 kValueFieldNumber = 2,
1147 };
1148 // string key = 1;
1149 void clear_key();
1150 const std::string& key() const;
1151 void set_key(const std::string& value);
1152 void set_key(std::string&& value);
1153 void set_key(const char* value);
1154 void set_key(const char* value, size_t size);
1155 std::string* mutable_key();
1156 std::string* release_key();
1157 void set_allocated_key(std::string* key);
1158
1159 // .tensorflow.StructuredValue value = 2;
1160 bool has_value() const;
1161 void clear_value();
1162 const ::tensorflow::StructuredValue& value() const;
1163 ::tensorflow::StructuredValue* release_value();
1164 ::tensorflow::StructuredValue* mutable_value();
1165 void set_allocated_value(::tensorflow::StructuredValue* value);
1166
1167 // @@protoc_insertion_point(class_scope:tensorflow.PairValue)
1168 private:
1169 class _Internal;
1170
1171 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1172 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
1173 ::tensorflow::StructuredValue* value_;
1174 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1175 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1176};
1177// -------------------------------------------------------------------
1178
1179class NamedTupleValue :
1180 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NamedTupleValue) */ {
1181 public:
1182 NamedTupleValue();
1183 virtual ~NamedTupleValue();
1184
1185 NamedTupleValue(const NamedTupleValue& from);
1186 NamedTupleValue(NamedTupleValue&& from) noexcept
1187 : NamedTupleValue() {
1188 *this = ::std::move(from);
1189 }
1190
1191 inline NamedTupleValue& operator=(const NamedTupleValue& from) {
1192 CopyFrom(from);
1193 return *this;
1194 }
1195 inline NamedTupleValue& operator=(NamedTupleValue&& from) noexcept {
1196 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1197 if (this != &from) InternalSwap(&from);
1198 } else {
1199 CopyFrom(from);
1200 }
1201 return *this;
1202 }
1203
1204 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1205 return GetDescriptor();
1206 }
1207 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1208 return GetMetadataStatic().descriptor;
1209 }
1210 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1211 return GetMetadataStatic().reflection;
1212 }
1213 static const NamedTupleValue& default_instance();
1214
1215 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1216 static inline const NamedTupleValue* internal_default_instance() {
1217 return reinterpret_cast<const NamedTupleValue*>(
1218 &_NamedTupleValue_default_instance_);
1219 }
1220 static constexpr int kIndexInFileMessages =
1221 7;
1222
1223 friend void swap(NamedTupleValue& a, NamedTupleValue& b) {
1224 a.Swap(&b);
1225 }
1226 inline void Swap(NamedTupleValue* other) {
1227 if (other == this) return;
1228 InternalSwap(other);
1229 }
1230
1231 // implements Message ----------------------------------------------
1232
1233 inline NamedTupleValue* New() const final {
1234 return CreateMaybeMessage<NamedTupleValue>(nullptr);
1235 }
1236
1237 NamedTupleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1238 return CreateMaybeMessage<NamedTupleValue>(arena);
1239 }
1240 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1241 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1242 void CopyFrom(const NamedTupleValue& from);
1243 void MergeFrom(const NamedTupleValue& from);
1244 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1245 bool IsInitialized() const final;
1246
1247 size_t ByteSizeLong() const final;
1248 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1249 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1250 #else
1251 bool MergePartialFromCodedStream(
1252 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1253 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1254 void SerializeWithCachedSizes(
1255 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1256 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1257 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1258 int GetCachedSize() const final { return _cached_size_.Get(); }
1259
1260 private:
1261 inline void SharedCtor();
1262 inline void SharedDtor();
1263 void SetCachedSize(int size) const final;
1264 void InternalSwap(NamedTupleValue* other);
1265 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1266 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1267 return "tensorflow.NamedTupleValue";
1268 }
1269 private:
1270 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1271 return nullptr;
1272 }
1273 inline void* MaybeArenaPtr() const {
1274 return nullptr;
1275 }
1276 public:
1277
1278 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1279 private:
1280 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1281 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
1282 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
1283 }
1284
1285 public:
1286
1287 // nested types ----------------------------------------------------
1288
1289 // accessors -------------------------------------------------------
1290
1291 enum : int {
1292 kValuesFieldNumber = 2,
1293 kNameFieldNumber = 1,
1294 };
1295 // repeated .tensorflow.PairValue values = 2;
1296 int values_size() const;
1297 void clear_values();
1298 ::tensorflow::PairValue* mutable_values(int index);
1299 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::PairValue >*
1300 mutable_values();
1301 const ::tensorflow::PairValue& values(int index) const;
1302 ::tensorflow::PairValue* add_values();
1303 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::PairValue >&
1304 values() const;
1305
1306 // string name = 1;
1307 void clear_name();
1308 const std::string& name() const;
1309 void set_name(const std::string& value);
1310 void set_name(std::string&& value);
1311 void set_name(const char* value);
1312 void set_name(const char* value, size_t size);
1313 std::string* mutable_name();
1314 std::string* release_name();
1315 void set_allocated_name(std::string* name);
1316
1317 // @@protoc_insertion_point(class_scope:tensorflow.NamedTupleValue)
1318 private:
1319 class _Internal;
1320
1321 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1322 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::PairValue > values_;
1323 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1324 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1325 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1326};
1327// -------------------------------------------------------------------
1328
1329class TensorSpecProto :
1330 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TensorSpecProto) */ {
1331 public:
1332 TensorSpecProto();
1333 virtual ~TensorSpecProto();
1334
1335 TensorSpecProto(const TensorSpecProto& from);
1336 TensorSpecProto(TensorSpecProto&& from) noexcept
1337 : TensorSpecProto() {
1338 *this = ::std::move(from);
1339 }
1340
1341 inline TensorSpecProto& operator=(const TensorSpecProto& from) {
1342 CopyFrom(from);
1343 return *this;
1344 }
1345 inline TensorSpecProto& operator=(TensorSpecProto&& from) noexcept {
1346 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1347 if (this != &from) InternalSwap(&from);
1348 } else {
1349 CopyFrom(from);
1350 }
1351 return *this;
1352 }
1353
1354 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1355 return GetDescriptor();
1356 }
1357 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1358 return GetMetadataStatic().descriptor;
1359 }
1360 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1361 return GetMetadataStatic().reflection;
1362 }
1363 static const TensorSpecProto& default_instance();
1364
1365 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1366 static inline const TensorSpecProto* internal_default_instance() {
1367 return reinterpret_cast<const TensorSpecProto*>(
1368 &_TensorSpecProto_default_instance_);
1369 }
1370 static constexpr int kIndexInFileMessages =
1371 8;
1372
1373 friend void swap(TensorSpecProto& a, TensorSpecProto& b) {
1374 a.Swap(&b);
1375 }
1376 inline void Swap(TensorSpecProto* other) {
1377 if (other == this) return;
1378 InternalSwap(other);
1379 }
1380
1381 // implements Message ----------------------------------------------
1382
1383 inline TensorSpecProto* New() const final {
1384 return CreateMaybeMessage<TensorSpecProto>(nullptr);
1385 }
1386
1387 TensorSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1388 return CreateMaybeMessage<TensorSpecProto>(arena);
1389 }
1390 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1391 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1392 void CopyFrom(const TensorSpecProto& from);
1393 void MergeFrom(const TensorSpecProto& from);
1394 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1395 bool IsInitialized() const final;
1396
1397 size_t ByteSizeLong() const final;
1398 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1399 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1400 #else
1401 bool MergePartialFromCodedStream(
1402 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1403 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1404 void SerializeWithCachedSizes(
1405 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1406 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1407 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1408 int GetCachedSize() const final { return _cached_size_.Get(); }
1409
1410 private:
1411 inline void SharedCtor();
1412 inline void SharedDtor();
1413 void SetCachedSize(int size) const final;
1414 void InternalSwap(TensorSpecProto* other);
1415 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1416 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1417 return "tensorflow.TensorSpecProto";
1418 }
1419 private:
1420 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1421 return nullptr;
1422 }
1423 inline void* MaybeArenaPtr() const {
1424 return nullptr;
1425 }
1426 public:
1427
1428 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1429 private:
1430 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1431 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
1432 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
1433 }
1434
1435 public:
1436
1437 // nested types ----------------------------------------------------
1438
1439 // accessors -------------------------------------------------------
1440
1441 enum : int {
1442 kNameFieldNumber = 1,
1443 kShapeFieldNumber = 2,
1444 kDtypeFieldNumber = 3,
1445 };
1446 // string name = 1;
1447 void clear_name();
1448 const std::string& name() const;
1449 void set_name(const std::string& value);
1450 void set_name(std::string&& value);
1451 void set_name(const char* value);
1452 void set_name(const char* value, size_t size);
1453 std::string* mutable_name();
1454 std::string* release_name();
1455 void set_allocated_name(std::string* name);
1456
1457 // .tensorflow.TensorShapeProto shape = 2;
1458 bool has_shape() const;
1459 void clear_shape();
1460 const ::tensorflow::TensorShapeProto& shape() const;
1461 ::tensorflow::TensorShapeProto* release_shape();
1462 ::tensorflow::TensorShapeProto* mutable_shape();
1463 void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
1464
1465 // .tensorflow.DataType dtype = 3;
1466 void clear_dtype();
1467 ::tensorflow::DataType dtype() const;
1468 void set_dtype(::tensorflow::DataType value);
1469
1470 // @@protoc_insertion_point(class_scope:tensorflow.TensorSpecProto)
1471 private:
1472 class _Internal;
1473
1474 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1475 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1476 ::tensorflow::TensorShapeProto* shape_;
1477 int dtype_;
1478 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1479 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1480};
1481// -------------------------------------------------------------------
1482
1483class BoundedTensorSpecProto :
1484 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BoundedTensorSpecProto) */ {
1485 public:
1486 BoundedTensorSpecProto();
1487 virtual ~BoundedTensorSpecProto();
1488
1489 BoundedTensorSpecProto(const BoundedTensorSpecProto& from);
1490 BoundedTensorSpecProto(BoundedTensorSpecProto&& from) noexcept
1491 : BoundedTensorSpecProto() {
1492 *this = ::std::move(from);
1493 }
1494
1495 inline BoundedTensorSpecProto& operator=(const BoundedTensorSpecProto& from) {
1496 CopyFrom(from);
1497 return *this;
1498 }
1499 inline BoundedTensorSpecProto& operator=(BoundedTensorSpecProto&& from) noexcept {
1500 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1501 if (this != &from) InternalSwap(&from);
1502 } else {
1503 CopyFrom(from);
1504 }
1505 return *this;
1506 }
1507
1508 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1509 return GetDescriptor();
1510 }
1511 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1512 return GetMetadataStatic().descriptor;
1513 }
1514 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1515 return GetMetadataStatic().reflection;
1516 }
1517 static const BoundedTensorSpecProto& default_instance();
1518
1519 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1520 static inline const BoundedTensorSpecProto* internal_default_instance() {
1521 return reinterpret_cast<const BoundedTensorSpecProto*>(
1522 &_BoundedTensorSpecProto_default_instance_);
1523 }
1524 static constexpr int kIndexInFileMessages =
1525 9;
1526
1527 friend void swap(BoundedTensorSpecProto& a, BoundedTensorSpecProto& b) {
1528 a.Swap(&b);
1529 }
1530 inline void Swap(BoundedTensorSpecProto* other) {
1531 if (other == this) return;
1532 InternalSwap(other);
1533 }
1534
1535 // implements Message ----------------------------------------------
1536
1537 inline BoundedTensorSpecProto* New() const final {
1538 return CreateMaybeMessage<BoundedTensorSpecProto>(nullptr);
1539 }
1540
1541 BoundedTensorSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1542 return CreateMaybeMessage<BoundedTensorSpecProto>(arena);
1543 }
1544 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1545 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1546 void CopyFrom(const BoundedTensorSpecProto& from);
1547 void MergeFrom(const BoundedTensorSpecProto& from);
1548 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1549 bool IsInitialized() const final;
1550
1551 size_t ByteSizeLong() const final;
1552 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1553 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1554 #else
1555 bool MergePartialFromCodedStream(
1556 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1557 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1558 void SerializeWithCachedSizes(
1559 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1560 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1561 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1562 int GetCachedSize() const final { return _cached_size_.Get(); }
1563
1564 private:
1565 inline void SharedCtor();
1566 inline void SharedDtor();
1567 void SetCachedSize(int size) const final;
1568 void InternalSwap(BoundedTensorSpecProto* other);
1569 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1570 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1571 return "tensorflow.BoundedTensorSpecProto";
1572 }
1573 private:
1574 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1575 return nullptr;
1576 }
1577 inline void* MaybeArenaPtr() const {
1578 return nullptr;
1579 }
1580 public:
1581
1582 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1583 private:
1584 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1585 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
1586 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
1587 }
1588
1589 public:
1590
1591 // nested types ----------------------------------------------------
1592
1593 // accessors -------------------------------------------------------
1594
1595 enum : int {
1596 kNameFieldNumber = 1,
1597 kShapeFieldNumber = 2,
1598 kMinimumFieldNumber = 4,
1599 kMaximumFieldNumber = 5,
1600 kDtypeFieldNumber = 3,
1601 };
1602 // string name = 1;
1603 void clear_name();
1604 const std::string& name() const;
1605 void set_name(const std::string& value);
1606 void set_name(std::string&& value);
1607 void set_name(const char* value);
1608 void set_name(const char* value, size_t size);
1609 std::string* mutable_name();
1610 std::string* release_name();
1611 void set_allocated_name(std::string* name);
1612
1613 // .tensorflow.TensorShapeProto shape = 2;
1614 bool has_shape() const;
1615 void clear_shape();
1616 const ::tensorflow::TensorShapeProto& shape() const;
1617 ::tensorflow::TensorShapeProto* release_shape();
1618 ::tensorflow::TensorShapeProto* mutable_shape();
1619 void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
1620
1621 // .tensorflow.TensorProto minimum = 4;
1622 bool has_minimum() const;
1623 void clear_minimum();
1624 const ::tensorflow::TensorProto& minimum() const;
1625 ::tensorflow::TensorProto* release_minimum();
1626 ::tensorflow::TensorProto* mutable_minimum();
1627 void set_allocated_minimum(::tensorflow::TensorProto* minimum);
1628
1629 // .tensorflow.TensorProto maximum = 5;
1630 bool has_maximum() const;
1631 void clear_maximum();
1632 const ::tensorflow::TensorProto& maximum() const;
1633 ::tensorflow::TensorProto* release_maximum();
1634 ::tensorflow::TensorProto* mutable_maximum();
1635 void set_allocated_maximum(::tensorflow::TensorProto* maximum);
1636
1637 // .tensorflow.DataType dtype = 3;
1638 void clear_dtype();
1639 ::tensorflow::DataType dtype() const;
1640 void set_dtype(::tensorflow::DataType value);
1641
1642 // @@protoc_insertion_point(class_scope:tensorflow.BoundedTensorSpecProto)
1643 private:
1644 class _Internal;
1645
1646 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1647 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1648 ::tensorflow::TensorShapeProto* shape_;
1649 ::tensorflow::TensorProto* minimum_;
1650 ::tensorflow::TensorProto* maximum_;
1651 int dtype_;
1652 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1653 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1654};
1655// -------------------------------------------------------------------
1656
1657class TypeSpecProto :
1658 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TypeSpecProto) */ {
1659 public:
1660 TypeSpecProto();
1661 virtual ~TypeSpecProto();
1662
1663 TypeSpecProto(const TypeSpecProto& from);
1664 TypeSpecProto(TypeSpecProto&& from) noexcept
1665 : TypeSpecProto() {
1666 *this = ::std::move(from);
1667 }
1668
1669 inline TypeSpecProto& operator=(const TypeSpecProto& from) {
1670 CopyFrom(from);
1671 return *this;
1672 }
1673 inline TypeSpecProto& operator=(TypeSpecProto&& from) noexcept {
1674 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1675 if (this != &from) InternalSwap(&from);
1676 } else {
1677 CopyFrom(from);
1678 }
1679 return *this;
1680 }
1681
1682 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1683 return GetDescriptor();
1684 }
1685 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1686 return GetMetadataStatic().descriptor;
1687 }
1688 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1689 return GetMetadataStatic().reflection;
1690 }
1691 static const TypeSpecProto& default_instance();
1692
1693 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1694 static inline const TypeSpecProto* internal_default_instance() {
1695 return reinterpret_cast<const TypeSpecProto*>(
1696 &_TypeSpecProto_default_instance_);
1697 }
1698 static constexpr int kIndexInFileMessages =
1699 10;
1700
1701 friend void swap(TypeSpecProto& a, TypeSpecProto& b) {
1702 a.Swap(&b);
1703 }
1704 inline void Swap(TypeSpecProto* other) {
1705 if (other == this) return;
1706 InternalSwap(other);
1707 }
1708
1709 // implements Message ----------------------------------------------
1710
1711 inline TypeSpecProto* New() const final {
1712 return CreateMaybeMessage<TypeSpecProto>(nullptr);
1713 }
1714
1715 TypeSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1716 return CreateMaybeMessage<TypeSpecProto>(arena);
1717 }
1718 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1719 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1720 void CopyFrom(const TypeSpecProto& from);
1721 void MergeFrom(const TypeSpecProto& from);
1722 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1723 bool IsInitialized() const final;
1724
1725 size_t ByteSizeLong() const final;
1726 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1727 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1728 #else
1729 bool MergePartialFromCodedStream(
1730 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1731 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1732 void SerializeWithCachedSizes(
1733 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1734 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1735 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1736 int GetCachedSize() const final { return _cached_size_.Get(); }
1737
1738 private:
1739 inline void SharedCtor();
1740 inline void SharedDtor();
1741 void SetCachedSize(int size) const final;
1742 void InternalSwap(TypeSpecProto* other);
1743 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1744 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1745 return "tensorflow.TypeSpecProto";
1746 }
1747 private:
1748 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1749 return nullptr;
1750 }
1751 inline void* MaybeArenaPtr() const {
1752 return nullptr;
1753 }
1754 public:
1755
1756 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1757 private:
1758 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1759 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto);
1760 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto.file_level_metadata[kIndexInFileMessages];
1761 }
1762
1763 public:
1764
1765 // nested types ----------------------------------------------------
1766
1767 typedef TypeSpecProto_TypeSpecClass TypeSpecClass;
1768 static constexpr TypeSpecClass UNKNOWN =
1769 TypeSpecProto_TypeSpecClass_UNKNOWN;
1770 static constexpr TypeSpecClass SPARSE_TENSOR_SPEC =
1771 TypeSpecProto_TypeSpecClass_SPARSE_TENSOR_SPEC;
1772 static constexpr TypeSpecClass INDEXED_SLICES_SPEC =
1773 TypeSpecProto_TypeSpecClass_INDEXED_SLICES_SPEC;
1774 static constexpr TypeSpecClass RAGGED_TENSOR_SPEC =
1775 TypeSpecProto_TypeSpecClass_RAGGED_TENSOR_SPEC;
1776 static constexpr TypeSpecClass TENSOR_ARRAY_SPEC =
1777 TypeSpecProto_TypeSpecClass_TENSOR_ARRAY_SPEC;
1778 static constexpr TypeSpecClass DATA_DATASET_SPEC =
1779 TypeSpecProto_TypeSpecClass_DATA_DATASET_SPEC;
1780 static constexpr TypeSpecClass DATA_ITERATOR_SPEC =
1781 TypeSpecProto_TypeSpecClass_DATA_ITERATOR_SPEC;
1782 static constexpr TypeSpecClass OPTIONAL_SPEC =
1783 TypeSpecProto_TypeSpecClass_OPTIONAL_SPEC;
1784 static constexpr TypeSpecClass PER_REPLICA_SPEC =
1785 TypeSpecProto_TypeSpecClass_PER_REPLICA_SPEC;
1786 static constexpr TypeSpecClass VARIABLE_SPEC =
1787 TypeSpecProto_TypeSpecClass_VARIABLE_SPEC;
1788 static constexpr TypeSpecClass ROW_PARTITION_SPEC =
1789 TypeSpecProto_TypeSpecClass_ROW_PARTITION_SPEC;
1790 static constexpr TypeSpecClass REGISTERED_TYPE_SPEC =
1791 TypeSpecProto_TypeSpecClass_REGISTERED_TYPE_SPEC;
1792 static constexpr TypeSpecClass EXTENSION_TYPE_SPEC =
1793 TypeSpecProto_TypeSpecClass_EXTENSION_TYPE_SPEC;
1794 static inline bool TypeSpecClass_IsValid(int value) {
1795 return TypeSpecProto_TypeSpecClass_IsValid(value);
1796 }
1797 static constexpr TypeSpecClass TypeSpecClass_MIN =
1798 TypeSpecProto_TypeSpecClass_TypeSpecClass_MIN;
1799 static constexpr TypeSpecClass TypeSpecClass_MAX =
1800 TypeSpecProto_TypeSpecClass_TypeSpecClass_MAX;
1801 static constexpr int TypeSpecClass_ARRAYSIZE =
1802 TypeSpecProto_TypeSpecClass_TypeSpecClass_ARRAYSIZE;
1803 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
1804 TypeSpecClass_descriptor() {
1805 return TypeSpecProto_TypeSpecClass_descriptor();
1806 }
1807 template<typename T>
1808 static inline const std::string& TypeSpecClass_Name(T enum_t_value) {
1809 static_assert(::std::is_same<T, TypeSpecClass>::value ||
1810 ::std::is_integral<T>::value,
1811 "Incorrect type passed to function TypeSpecClass_Name.");
1812 return TypeSpecProto_TypeSpecClass_Name(enum_t_value);
1813 }
1814 static inline bool TypeSpecClass_Parse(const std::string& name,
1815 TypeSpecClass* value) {
1816 return TypeSpecProto_TypeSpecClass_Parse(name, value);
1817 }
1818
1819 // accessors -------------------------------------------------------
1820
1821 enum : int {
1822 kTypeSpecClassNameFieldNumber = 3,
1823 kTypeStateFieldNumber = 2,
1824 kTypeSpecClassFieldNumber = 1,
1825 kNumFlatComponentsFieldNumber = 4,
1826 };
1827 // string type_spec_class_name = 3;
1828 void clear_type_spec_class_name();
1829 const std::string& type_spec_class_name() const;
1830 void set_type_spec_class_name(const std::string& value);
1831 void set_type_spec_class_name(std::string&& value);
1832 void set_type_spec_class_name(const char* value);
1833 void set_type_spec_class_name(const char* value, size_t size);
1834 std::string* mutable_type_spec_class_name();
1835 std::string* release_type_spec_class_name();
1836 void set_allocated_type_spec_class_name(std::string* type_spec_class_name);
1837
1838 // .tensorflow.StructuredValue type_state = 2;
1839 bool has_type_state() const;
1840 void clear_type_state();
1841 const ::tensorflow::StructuredValue& type_state() const;
1842 ::tensorflow::StructuredValue* release_type_state();
1843 ::tensorflow::StructuredValue* mutable_type_state();
1844 void set_allocated_type_state(::tensorflow::StructuredValue* type_state);
1845
1846 // .tensorflow.TypeSpecProto.TypeSpecClass type_spec_class = 1;
1847 void clear_type_spec_class();
1848 ::tensorflow::TypeSpecProto_TypeSpecClass type_spec_class() const;
1849 void set_type_spec_class(::tensorflow::TypeSpecProto_TypeSpecClass value);
1850
1851 // int32 num_flat_components = 4;
1852 void clear_num_flat_components();
1853 ::PROTOBUF_NAMESPACE_ID::int32 num_flat_components() const;
1854 void set_num_flat_components(::PROTOBUF_NAMESPACE_ID::int32 value);
1855
1856 // @@protoc_insertion_point(class_scope:tensorflow.TypeSpecProto)
1857 private:
1858 class _Internal;
1859
1860 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1861 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_spec_class_name_;
1862 ::tensorflow::StructuredValue* type_state_;
1863 int type_spec_class_;
1864 ::PROTOBUF_NAMESPACE_ID::int32 num_flat_components_;
1865 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1866 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto;
1867};
1868// ===================================================================
1869
1870
1871// ===================================================================
1872
1873#ifdef __GNUC__
1874 #pragma GCC diagnostic push
1875 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1876#endif // __GNUC__
1877// StructuredValue
1878
1879// .tensorflow.NoneValue none_value = 1;
1880inline bool StructuredValue::has_none_value() const {
1881 return kind_case() == kNoneValue;
1882}
1883inline void StructuredValue::set_has_none_value() {
1884 _oneof_case_[0] = kNoneValue;
1885}
1886inline void StructuredValue::clear_none_value() {
1887 if (has_none_value()) {
1888 delete kind_.none_value_;
1889 clear_has_kind();
1890 }
1891}
1892inline ::tensorflow::NoneValue* StructuredValue::release_none_value() {
1893 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.none_value)
1894 if (has_none_value()) {
1895 clear_has_kind();
1896 ::tensorflow::NoneValue* temp = kind_.none_value_;
1897 kind_.none_value_ = nullptr;
1898 return temp;
1899 } else {
1900 return nullptr;
1901 }
1902}
1903inline const ::tensorflow::NoneValue& StructuredValue::none_value() const {
1904 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.none_value)
1905 return has_none_value()
1906 ? *kind_.none_value_
1907 : *reinterpret_cast< ::tensorflow::NoneValue*>(&::tensorflow::_NoneValue_default_instance_);
1908}
1909inline ::tensorflow::NoneValue* StructuredValue::mutable_none_value() {
1910 if (!has_none_value()) {
1911 clear_kind();
1912 set_has_none_value();
1913 kind_.none_value_ = CreateMaybeMessage< ::tensorflow::NoneValue >(
1914 GetArenaNoVirtual());
1915 }
1916 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.none_value)
1917 return kind_.none_value_;
1918}
1919
1920// double float64_value = 11;
1921inline bool StructuredValue::has_float64_value() const {
1922 return kind_case() == kFloat64Value;
1923}
1924inline void StructuredValue::set_has_float64_value() {
1925 _oneof_case_[0] = kFloat64Value;
1926}
1927inline void StructuredValue::clear_float64_value() {
1928 if (has_float64_value()) {
1929 kind_.float64_value_ = 0;
1930 clear_has_kind();
1931 }
1932}
1933inline double StructuredValue::float64_value() const {
1934 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.float64_value)
1935 if (has_float64_value()) {
1936 return kind_.float64_value_;
1937 }
1938 return 0;
1939}
1940inline void StructuredValue::set_float64_value(double value) {
1941 if (!has_float64_value()) {
1942 clear_kind();
1943 set_has_float64_value();
1944 }
1945 kind_.float64_value_ = value;
1946 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.float64_value)
1947}
1948
1949// sint64 int64_value = 12;
1950inline bool StructuredValue::has_int64_value() const {
1951 return kind_case() == kInt64Value;
1952}
1953inline void StructuredValue::set_has_int64_value() {
1954 _oneof_case_[0] = kInt64Value;
1955}
1956inline void StructuredValue::clear_int64_value() {
1957 if (has_int64_value()) {
1958 kind_.int64_value_ = PROTOBUF_LONGLONG(0);
1959 clear_has_kind();
1960 }
1961}
1962inline ::PROTOBUF_NAMESPACE_ID::int64 StructuredValue::int64_value() const {
1963 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.int64_value)
1964 if (has_int64_value()) {
1965 return kind_.int64_value_;
1966 }
1967 return PROTOBUF_LONGLONG(0);
1968}
1969inline void StructuredValue::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
1970 if (!has_int64_value()) {
1971 clear_kind();
1972 set_has_int64_value();
1973 }
1974 kind_.int64_value_ = value;
1975 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.int64_value)
1976}
1977
1978// string string_value = 13;
1979inline bool StructuredValue::has_string_value() const {
1980 return kind_case() == kStringValue;
1981}
1982inline void StructuredValue::set_has_string_value() {
1983 _oneof_case_[0] = kStringValue;
1984}
1985inline void StructuredValue::clear_string_value() {
1986 if (has_string_value()) {
1987 kind_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1988 clear_has_kind();
1989 }
1990}
1991inline const std::string& StructuredValue::string_value() const {
1992 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.string_value)
1993 if (has_string_value()) {
1994 return kind_.string_value_.GetNoArena();
1995 }
1996 return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
1997}
1998inline void StructuredValue::set_string_value(const std::string& value) {
1999 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.string_value)
2000 if (!has_string_value()) {
2001 clear_kind();
2002 set_has_string_value();
2003 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2004 }
2005 kind_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2006 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.string_value)
2007}
2008inline void StructuredValue::set_string_value(std::string&& value) {
2009 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.string_value)
2010 if (!has_string_value()) {
2011 clear_kind();
2012 set_has_string_value();
2013 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2014 }
2015 kind_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2016 // @@protoc_insertion_point(field_set_rvalue:tensorflow.StructuredValue.string_value)
2017}
2018inline void StructuredValue::set_string_value(const char* value) {
2019 GOOGLE_DCHECK(value != nullptr);
2020 if (!has_string_value()) {
2021 clear_kind();
2022 set_has_string_value();
2023 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2024 }
2025 kind_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2026 ::std::string(value));
2027 // @@protoc_insertion_point(field_set_char:tensorflow.StructuredValue.string_value)
2028}
2029inline void StructuredValue::set_string_value(const char* value, size_t size) {
2030 if (!has_string_value()) {
2031 clear_kind();
2032 set_has_string_value();
2033 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2034 }
2035 kind_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
2036 reinterpret_cast<const char*>(value), size));
2037 // @@protoc_insertion_point(field_set_pointer:tensorflow.StructuredValue.string_value)
2038}
2039inline std::string* StructuredValue::mutable_string_value() {
2040 if (!has_string_value()) {
2041 clear_kind();
2042 set_has_string_value();
2043 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2044 }
2045 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.string_value)
2046 return kind_.string_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2047}
2048inline std::string* StructuredValue::release_string_value() {
2049 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.string_value)
2050 if (has_string_value()) {
2051 clear_has_kind();
2052 return kind_.string_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2053 } else {
2054 return nullptr;
2055 }
2056}
2057inline void StructuredValue::set_allocated_string_value(std::string* string_value) {
2058 if (has_kind()) {
2059 clear_kind();
2060 }
2061 if (string_value != nullptr) {
2062 set_has_string_value();
2063 kind_.string_value_.UnsafeSetDefault(string_value);
2064 }
2065 // @@protoc_insertion_point(field_set_allocated:tensorflow.StructuredValue.string_value)
2066}
2067
2068// bool bool_value = 14;
2069inline bool StructuredValue::has_bool_value() const {
2070 return kind_case() == kBoolValue;
2071}
2072inline void StructuredValue::set_has_bool_value() {
2073 _oneof_case_[0] = kBoolValue;
2074}
2075inline void StructuredValue::clear_bool_value() {
2076 if (has_bool_value()) {
2077 kind_.bool_value_ = false;
2078 clear_has_kind();
2079 }
2080}
2081inline bool StructuredValue::bool_value() const {
2082 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.bool_value)
2083 if (has_bool_value()) {
2084 return kind_.bool_value_;
2085 }
2086 return false;
2087}
2088inline void StructuredValue::set_bool_value(bool value) {
2089 if (!has_bool_value()) {
2090 clear_kind();
2091 set_has_bool_value();
2092 }
2093 kind_.bool_value_ = value;
2094 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.bool_value)
2095}
2096
2097// .tensorflow.TensorShapeProto tensor_shape_value = 31;
2098inline bool StructuredValue::has_tensor_shape_value() const {
2099 return kind_case() == kTensorShapeValue;
2100}
2101inline void StructuredValue::set_has_tensor_shape_value() {
2102 _oneof_case_[0] = kTensorShapeValue;
2103}
2104inline ::tensorflow::TensorShapeProto* StructuredValue::release_tensor_shape_value() {
2105 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.tensor_shape_value)
2106 if (has_tensor_shape_value()) {
2107 clear_has_kind();
2108 ::tensorflow::TensorShapeProto* temp = kind_.tensor_shape_value_;
2109 kind_.tensor_shape_value_ = nullptr;
2110 return temp;
2111 } else {
2112 return nullptr;
2113 }
2114}
2115inline const ::tensorflow::TensorShapeProto& StructuredValue::tensor_shape_value() const {
2116 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.tensor_shape_value)
2117 return has_tensor_shape_value()
2118 ? *kind_.tensor_shape_value_
2119 : *reinterpret_cast< ::tensorflow::TensorShapeProto*>(&::tensorflow::_TensorShapeProto_default_instance_);
2120}
2121inline ::tensorflow::TensorShapeProto* StructuredValue::mutable_tensor_shape_value() {
2122 if (!has_tensor_shape_value()) {
2123 clear_kind();
2124 set_has_tensor_shape_value();
2125 kind_.tensor_shape_value_ = CreateMaybeMessage< ::tensorflow::TensorShapeProto >(
2126 GetArenaNoVirtual());
2127 }
2128 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.tensor_shape_value)
2129 return kind_.tensor_shape_value_;
2130}
2131
2132// .tensorflow.DataType tensor_dtype_value = 32;
2133inline bool StructuredValue::has_tensor_dtype_value() const {
2134 return kind_case() == kTensorDtypeValue;
2135}
2136inline void StructuredValue::set_has_tensor_dtype_value() {
2137 _oneof_case_[0] = kTensorDtypeValue;
2138}
2139inline void StructuredValue::clear_tensor_dtype_value() {
2140 if (has_tensor_dtype_value()) {
2141 kind_.tensor_dtype_value_ = 0;
2142 clear_has_kind();
2143 }
2144}
2145inline ::tensorflow::DataType StructuredValue::tensor_dtype_value() const {
2146 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.tensor_dtype_value)
2147 if (has_tensor_dtype_value()) {
2148 return static_cast< ::tensorflow::DataType >(kind_.tensor_dtype_value_);
2149 }
2150 return static_cast< ::tensorflow::DataType >(0);
2151}
2152inline void StructuredValue::set_tensor_dtype_value(::tensorflow::DataType value) {
2153 if (!has_tensor_dtype_value()) {
2154 clear_kind();
2155 set_has_tensor_dtype_value();
2156 }
2157 kind_.tensor_dtype_value_ = value;
2158 // @@protoc_insertion_point(field_set:tensorflow.StructuredValue.tensor_dtype_value)
2159}
2160
2161// .tensorflow.TensorSpecProto tensor_spec_value = 33;
2162inline bool StructuredValue::has_tensor_spec_value() const {
2163 return kind_case() == kTensorSpecValue;
2164}
2165inline void StructuredValue::set_has_tensor_spec_value() {
2166 _oneof_case_[0] = kTensorSpecValue;
2167}
2168inline void StructuredValue::clear_tensor_spec_value() {
2169 if (has_tensor_spec_value()) {
2170 delete kind_.tensor_spec_value_;
2171 clear_has_kind();
2172 }
2173}
2174inline ::tensorflow::TensorSpecProto* StructuredValue::release_tensor_spec_value() {
2175 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.tensor_spec_value)
2176 if (has_tensor_spec_value()) {
2177 clear_has_kind();
2178 ::tensorflow::TensorSpecProto* temp = kind_.tensor_spec_value_;
2179 kind_.tensor_spec_value_ = nullptr;
2180 return temp;
2181 } else {
2182 return nullptr;
2183 }
2184}
2185inline const ::tensorflow::TensorSpecProto& StructuredValue::tensor_spec_value() const {
2186 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.tensor_spec_value)
2187 return has_tensor_spec_value()
2188 ? *kind_.tensor_spec_value_
2189 : *reinterpret_cast< ::tensorflow::TensorSpecProto*>(&::tensorflow::_TensorSpecProto_default_instance_);
2190}
2191inline ::tensorflow::TensorSpecProto* StructuredValue::mutable_tensor_spec_value() {
2192 if (!has_tensor_spec_value()) {
2193 clear_kind();
2194 set_has_tensor_spec_value();
2195 kind_.tensor_spec_value_ = CreateMaybeMessage< ::tensorflow::TensorSpecProto >(
2196 GetArenaNoVirtual());
2197 }
2198 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.tensor_spec_value)
2199 return kind_.tensor_spec_value_;
2200}
2201
2202// .tensorflow.TypeSpecProto type_spec_value = 34;
2203inline bool StructuredValue::has_type_spec_value() const {
2204 return kind_case() == kTypeSpecValue;
2205}
2206inline void StructuredValue::set_has_type_spec_value() {
2207 _oneof_case_[0] = kTypeSpecValue;
2208}
2209inline void StructuredValue::clear_type_spec_value() {
2210 if (has_type_spec_value()) {
2211 delete kind_.type_spec_value_;
2212 clear_has_kind();
2213 }
2214}
2215inline ::tensorflow::TypeSpecProto* StructuredValue::release_type_spec_value() {
2216 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.type_spec_value)
2217 if (has_type_spec_value()) {
2218 clear_has_kind();
2219 ::tensorflow::TypeSpecProto* temp = kind_.type_spec_value_;
2220 kind_.type_spec_value_ = nullptr;
2221 return temp;
2222 } else {
2223 return nullptr;
2224 }
2225}
2226inline const ::tensorflow::TypeSpecProto& StructuredValue::type_spec_value() const {
2227 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.type_spec_value)
2228 return has_type_spec_value()
2229 ? *kind_.type_spec_value_
2230 : *reinterpret_cast< ::tensorflow::TypeSpecProto*>(&::tensorflow::_TypeSpecProto_default_instance_);
2231}
2232inline ::tensorflow::TypeSpecProto* StructuredValue::mutable_type_spec_value() {
2233 if (!has_type_spec_value()) {
2234 clear_kind();
2235 set_has_type_spec_value();
2236 kind_.type_spec_value_ = CreateMaybeMessage< ::tensorflow::TypeSpecProto >(
2237 GetArenaNoVirtual());
2238 }
2239 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.type_spec_value)
2240 return kind_.type_spec_value_;
2241}
2242
2243// .tensorflow.BoundedTensorSpecProto bounded_tensor_spec_value = 35;
2244inline bool StructuredValue::has_bounded_tensor_spec_value() const {
2245 return kind_case() == kBoundedTensorSpecValue;
2246}
2247inline void StructuredValue::set_has_bounded_tensor_spec_value() {
2248 _oneof_case_[0] = kBoundedTensorSpecValue;
2249}
2250inline void StructuredValue::clear_bounded_tensor_spec_value() {
2251 if (has_bounded_tensor_spec_value()) {
2252 delete kind_.bounded_tensor_spec_value_;
2253 clear_has_kind();
2254 }
2255}
2256inline ::tensorflow::BoundedTensorSpecProto* StructuredValue::release_bounded_tensor_spec_value() {
2257 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.bounded_tensor_spec_value)
2258 if (has_bounded_tensor_spec_value()) {
2259 clear_has_kind();
2260 ::tensorflow::BoundedTensorSpecProto* temp = kind_.bounded_tensor_spec_value_;
2261 kind_.bounded_tensor_spec_value_ = nullptr;
2262 return temp;
2263 } else {
2264 return nullptr;
2265 }
2266}
2267inline const ::tensorflow::BoundedTensorSpecProto& StructuredValue::bounded_tensor_spec_value() const {
2268 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.bounded_tensor_spec_value)
2269 return has_bounded_tensor_spec_value()
2270 ? *kind_.bounded_tensor_spec_value_
2271 : *reinterpret_cast< ::tensorflow::BoundedTensorSpecProto*>(&::tensorflow::_BoundedTensorSpecProto_default_instance_);
2272}
2273inline ::tensorflow::BoundedTensorSpecProto* StructuredValue::mutable_bounded_tensor_spec_value() {
2274 if (!has_bounded_tensor_spec_value()) {
2275 clear_kind();
2276 set_has_bounded_tensor_spec_value();
2277 kind_.bounded_tensor_spec_value_ = CreateMaybeMessage< ::tensorflow::BoundedTensorSpecProto >(
2278 GetArenaNoVirtual());
2279 }
2280 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.bounded_tensor_spec_value)
2281 return kind_.bounded_tensor_spec_value_;
2282}
2283
2284// .tensorflow.ListValue list_value = 51;
2285inline bool StructuredValue::has_list_value() const {
2286 return kind_case() == kListValue;
2287}
2288inline void StructuredValue::set_has_list_value() {
2289 _oneof_case_[0] = kListValue;
2290}
2291inline void StructuredValue::clear_list_value() {
2292 if (has_list_value()) {
2293 delete kind_.list_value_;
2294 clear_has_kind();
2295 }
2296}
2297inline ::tensorflow::ListValue* StructuredValue::release_list_value() {
2298 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.list_value)
2299 if (has_list_value()) {
2300 clear_has_kind();
2301 ::tensorflow::ListValue* temp = kind_.list_value_;
2302 kind_.list_value_ = nullptr;
2303 return temp;
2304 } else {
2305 return nullptr;
2306 }
2307}
2308inline const ::tensorflow::ListValue& StructuredValue::list_value() const {
2309 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.list_value)
2310 return has_list_value()
2311 ? *kind_.list_value_
2312 : *reinterpret_cast< ::tensorflow::ListValue*>(&::tensorflow::_ListValue_default_instance_);
2313}
2314inline ::tensorflow::ListValue* StructuredValue::mutable_list_value() {
2315 if (!has_list_value()) {
2316 clear_kind();
2317 set_has_list_value();
2318 kind_.list_value_ = CreateMaybeMessage< ::tensorflow::ListValue >(
2319 GetArenaNoVirtual());
2320 }
2321 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.list_value)
2322 return kind_.list_value_;
2323}
2324
2325// .tensorflow.TupleValue tuple_value = 52;
2326inline bool StructuredValue::has_tuple_value() const {
2327 return kind_case() == kTupleValue;
2328}
2329inline void StructuredValue::set_has_tuple_value() {
2330 _oneof_case_[0] = kTupleValue;
2331}
2332inline void StructuredValue::clear_tuple_value() {
2333 if (has_tuple_value()) {
2334 delete kind_.tuple_value_;
2335 clear_has_kind();
2336 }
2337}
2338inline ::tensorflow::TupleValue* StructuredValue::release_tuple_value() {
2339 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.tuple_value)
2340 if (has_tuple_value()) {
2341 clear_has_kind();
2342 ::tensorflow::TupleValue* temp = kind_.tuple_value_;
2343 kind_.tuple_value_ = nullptr;
2344 return temp;
2345 } else {
2346 return nullptr;
2347 }
2348}
2349inline const ::tensorflow::TupleValue& StructuredValue::tuple_value() const {
2350 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.tuple_value)
2351 return has_tuple_value()
2352 ? *kind_.tuple_value_
2353 : *reinterpret_cast< ::tensorflow::TupleValue*>(&::tensorflow::_TupleValue_default_instance_);
2354}
2355inline ::tensorflow::TupleValue* StructuredValue::mutable_tuple_value() {
2356 if (!has_tuple_value()) {
2357 clear_kind();
2358 set_has_tuple_value();
2359 kind_.tuple_value_ = CreateMaybeMessage< ::tensorflow::TupleValue >(
2360 GetArenaNoVirtual());
2361 }
2362 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.tuple_value)
2363 return kind_.tuple_value_;
2364}
2365
2366// .tensorflow.DictValue dict_value = 53;
2367inline bool StructuredValue::has_dict_value() const {
2368 return kind_case() == kDictValue;
2369}
2370inline void StructuredValue::set_has_dict_value() {
2371 _oneof_case_[0] = kDictValue;
2372}
2373inline void StructuredValue::clear_dict_value() {
2374 if (has_dict_value()) {
2375 delete kind_.dict_value_;
2376 clear_has_kind();
2377 }
2378}
2379inline ::tensorflow::DictValue* StructuredValue::release_dict_value() {
2380 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.dict_value)
2381 if (has_dict_value()) {
2382 clear_has_kind();
2383 ::tensorflow::DictValue* temp = kind_.dict_value_;
2384 kind_.dict_value_ = nullptr;
2385 return temp;
2386 } else {
2387 return nullptr;
2388 }
2389}
2390inline const ::tensorflow::DictValue& StructuredValue::dict_value() const {
2391 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.dict_value)
2392 return has_dict_value()
2393 ? *kind_.dict_value_
2394 : *reinterpret_cast< ::tensorflow::DictValue*>(&::tensorflow::_DictValue_default_instance_);
2395}
2396inline ::tensorflow::DictValue* StructuredValue::mutable_dict_value() {
2397 if (!has_dict_value()) {
2398 clear_kind();
2399 set_has_dict_value();
2400 kind_.dict_value_ = CreateMaybeMessage< ::tensorflow::DictValue >(
2401 GetArenaNoVirtual());
2402 }
2403 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.dict_value)
2404 return kind_.dict_value_;
2405}
2406
2407// .tensorflow.NamedTupleValue named_tuple_value = 54;
2408inline bool StructuredValue::has_named_tuple_value() const {
2409 return kind_case() == kNamedTupleValue;
2410}
2411inline void StructuredValue::set_has_named_tuple_value() {
2412 _oneof_case_[0] = kNamedTupleValue;
2413}
2414inline void StructuredValue::clear_named_tuple_value() {
2415 if (has_named_tuple_value()) {
2416 delete kind_.named_tuple_value_;
2417 clear_has_kind();
2418 }
2419}
2420inline ::tensorflow::NamedTupleValue* StructuredValue::release_named_tuple_value() {
2421 // @@protoc_insertion_point(field_release:tensorflow.StructuredValue.named_tuple_value)
2422 if (has_named_tuple_value()) {
2423 clear_has_kind();
2424 ::tensorflow::NamedTupleValue* temp = kind_.named_tuple_value_;
2425 kind_.named_tuple_value_ = nullptr;
2426 return temp;
2427 } else {
2428 return nullptr;
2429 }
2430}
2431inline const ::tensorflow::NamedTupleValue& StructuredValue::named_tuple_value() const {
2432 // @@protoc_insertion_point(field_get:tensorflow.StructuredValue.named_tuple_value)
2433 return has_named_tuple_value()
2434 ? *kind_.named_tuple_value_
2435 : *reinterpret_cast< ::tensorflow::NamedTupleValue*>(&::tensorflow::_NamedTupleValue_default_instance_);
2436}
2437inline ::tensorflow::NamedTupleValue* StructuredValue::mutable_named_tuple_value() {
2438 if (!has_named_tuple_value()) {
2439 clear_kind();
2440 set_has_named_tuple_value();
2441 kind_.named_tuple_value_ = CreateMaybeMessage< ::tensorflow::NamedTupleValue >(
2442 GetArenaNoVirtual());
2443 }
2444 // @@protoc_insertion_point(field_mutable:tensorflow.StructuredValue.named_tuple_value)
2445 return kind_.named_tuple_value_;
2446}
2447
2448inline bool StructuredValue::has_kind() const {
2449 return kind_case() != KIND_NOT_SET;
2450}
2451inline void StructuredValue::clear_has_kind() {
2452 _oneof_case_[0] = KIND_NOT_SET;
2453}
2454inline StructuredValue::KindCase StructuredValue::kind_case() const {
2455 return StructuredValue::KindCase(_oneof_case_[0]);
2456}
2457// -------------------------------------------------------------------
2458
2459// NoneValue
2460
2461// -------------------------------------------------------------------
2462
2463// ListValue
2464
2465// repeated .tensorflow.StructuredValue values = 1;
2466inline int ListValue::values_size() const {
2467 return values_.size();
2468}
2469inline void ListValue::clear_values() {
2470 values_.Clear();
2471}
2472inline ::tensorflow::StructuredValue* ListValue::mutable_values(int index) {
2473 // @@protoc_insertion_point(field_mutable:tensorflow.ListValue.values)
2474 return values_.Mutable(index);
2475}
2476inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >*
2477ListValue::mutable_values() {
2478 // @@protoc_insertion_point(field_mutable_list:tensorflow.ListValue.values)
2479 return &values_;
2480}
2481inline const ::tensorflow::StructuredValue& ListValue::values(int index) const {
2482 // @@protoc_insertion_point(field_get:tensorflow.ListValue.values)
2483 return values_.Get(index);
2484}
2485inline ::tensorflow::StructuredValue* ListValue::add_values() {
2486 // @@protoc_insertion_point(field_add:tensorflow.ListValue.values)
2487 return values_.Add();
2488}
2489inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >&
2490ListValue::values() const {
2491 // @@protoc_insertion_point(field_list:tensorflow.ListValue.values)
2492 return values_;
2493}
2494
2495// -------------------------------------------------------------------
2496
2497// TupleValue
2498
2499// repeated .tensorflow.StructuredValue values = 1;
2500inline int TupleValue::values_size() const {
2501 return values_.size();
2502}
2503inline void TupleValue::clear_values() {
2504 values_.Clear();
2505}
2506inline ::tensorflow::StructuredValue* TupleValue::mutable_values(int index) {
2507 // @@protoc_insertion_point(field_mutable:tensorflow.TupleValue.values)
2508 return values_.Mutable(index);
2509}
2510inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >*
2511TupleValue::mutable_values() {
2512 // @@protoc_insertion_point(field_mutable_list:tensorflow.TupleValue.values)
2513 return &values_;
2514}
2515inline const ::tensorflow::StructuredValue& TupleValue::values(int index) const {
2516 // @@protoc_insertion_point(field_get:tensorflow.TupleValue.values)
2517 return values_.Get(index);
2518}
2519inline ::tensorflow::StructuredValue* TupleValue::add_values() {
2520 // @@protoc_insertion_point(field_add:tensorflow.TupleValue.values)
2521 return values_.Add();
2522}
2523inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StructuredValue >&
2524TupleValue::values() const {
2525 // @@protoc_insertion_point(field_list:tensorflow.TupleValue.values)
2526 return values_;
2527}
2528
2529// -------------------------------------------------------------------
2530
2531// -------------------------------------------------------------------
2532
2533// DictValue
2534
2535// map<string, .tensorflow.StructuredValue> fields = 1;
2536inline int DictValue::fields_size() const {
2537 return fields_.size();
2538}
2539inline void DictValue::clear_fields() {
2540 fields_.Clear();
2541}
2542inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::StructuredValue >&
2543DictValue::fields() const {
2544 // @@protoc_insertion_point(field_map:tensorflow.DictValue.fields)
2545 return fields_.GetMap();
2546}
2547inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::StructuredValue >*
2548DictValue::mutable_fields() {
2549 // @@protoc_insertion_point(field_mutable_map:tensorflow.DictValue.fields)
2550 return fields_.MutableMap();
2551}
2552
2553// -------------------------------------------------------------------
2554
2555// PairValue
2556
2557// string key = 1;
2558inline void PairValue::clear_key() {
2559 key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2560}
2561inline const std::string& PairValue::key() const {
2562 // @@protoc_insertion_point(field_get:tensorflow.PairValue.key)
2563 return key_.GetNoArena();
2564}
2565inline void PairValue::set_key(const std::string& value) {
2566
2567 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2568 // @@protoc_insertion_point(field_set:tensorflow.PairValue.key)
2569}
2570inline void PairValue::set_key(std::string&& value) {
2571
2572 key_.SetNoArena(
2573 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2574 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PairValue.key)
2575}
2576inline void PairValue::set_key(const char* value) {
2577 GOOGLE_DCHECK(value != nullptr);
2578
2579 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2580 // @@protoc_insertion_point(field_set_char:tensorflow.PairValue.key)
2581}
2582inline void PairValue::set_key(const char* value, size_t size) {
2583
2584 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2585 ::std::string(reinterpret_cast<const char*>(value), size));
2586 // @@protoc_insertion_point(field_set_pointer:tensorflow.PairValue.key)
2587}
2588inline std::string* PairValue::mutable_key() {
2589
2590 // @@protoc_insertion_point(field_mutable:tensorflow.PairValue.key)
2591 return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2592}
2593inline std::string* PairValue::release_key() {
2594 // @@protoc_insertion_point(field_release:tensorflow.PairValue.key)
2595
2596 return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2597}
2598inline void PairValue::set_allocated_key(std::string* key) {
2599 if (key != nullptr) {
2600
2601 } else {
2602
2603 }
2604 key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
2605 // @@protoc_insertion_point(field_set_allocated:tensorflow.PairValue.key)
2606}
2607
2608// .tensorflow.StructuredValue value = 2;
2609inline bool PairValue::has_value() const {
2610 return this != internal_default_instance() && value_ != nullptr;
2611}
2612inline void PairValue::clear_value() {
2613 if (GetArenaNoVirtual() == nullptr && value_ != nullptr) {
2614 delete value_;
2615 }
2616 value_ = nullptr;
2617}
2618inline const ::tensorflow::StructuredValue& PairValue::value() const {
2619 const ::tensorflow::StructuredValue* p = value_;
2620 // @@protoc_insertion_point(field_get:tensorflow.PairValue.value)
2621 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::StructuredValue*>(
2622 &::tensorflow::_StructuredValue_default_instance_);
2623}
2624inline ::tensorflow::StructuredValue* PairValue::release_value() {
2625 // @@protoc_insertion_point(field_release:tensorflow.PairValue.value)
2626
2627 ::tensorflow::StructuredValue* temp = value_;
2628 value_ = nullptr;
2629 return temp;
2630}
2631inline ::tensorflow::StructuredValue* PairValue::mutable_value() {
2632
2633 if (value_ == nullptr) {
2634 auto* p = CreateMaybeMessage<::tensorflow::StructuredValue>(GetArenaNoVirtual());
2635 value_ = p;
2636 }
2637 // @@protoc_insertion_point(field_mutable:tensorflow.PairValue.value)
2638 return value_;
2639}
2640inline void PairValue::set_allocated_value(::tensorflow::StructuredValue* value) {
2641 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2642 if (message_arena == nullptr) {
2643 delete value_;
2644 }
2645 if (value) {
2646 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
2647 if (message_arena != submessage_arena) {
2648 value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2649 message_arena, value, submessage_arena);
2650 }
2651
2652 } else {
2653
2654 }
2655 value_ = value;
2656 // @@protoc_insertion_point(field_set_allocated:tensorflow.PairValue.value)
2657}
2658
2659// -------------------------------------------------------------------
2660
2661// NamedTupleValue
2662
2663// string name = 1;
2664inline void NamedTupleValue::clear_name() {
2665 name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2666}
2667inline const std::string& NamedTupleValue::name() const {
2668 // @@protoc_insertion_point(field_get:tensorflow.NamedTupleValue.name)
2669 return name_.GetNoArena();
2670}
2671inline void NamedTupleValue::set_name(const std::string& value) {
2672
2673 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2674 // @@protoc_insertion_point(field_set:tensorflow.NamedTupleValue.name)
2675}
2676inline void NamedTupleValue::set_name(std::string&& value) {
2677
2678 name_.SetNoArena(
2679 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2680 // @@protoc_insertion_point(field_set_rvalue:tensorflow.NamedTupleValue.name)
2681}
2682inline void NamedTupleValue::set_name(const char* value) {
2683 GOOGLE_DCHECK(value != nullptr);
2684
2685 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2686 // @@protoc_insertion_point(field_set_char:tensorflow.NamedTupleValue.name)
2687}
2688inline void NamedTupleValue::set_name(const char* value, size_t size) {
2689
2690 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2691 ::std::string(reinterpret_cast<const char*>(value), size));
2692 // @@protoc_insertion_point(field_set_pointer:tensorflow.NamedTupleValue.name)
2693}
2694inline std::string* NamedTupleValue::mutable_name() {
2695
2696 // @@protoc_insertion_point(field_mutable:tensorflow.NamedTupleValue.name)
2697 return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2698}
2699inline std::string* NamedTupleValue::release_name() {
2700 // @@protoc_insertion_point(field_release:tensorflow.NamedTupleValue.name)
2701
2702 return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2703}
2704inline void NamedTupleValue::set_allocated_name(std::string* name) {
2705 if (name != nullptr) {
2706
2707 } else {
2708
2709 }
2710 name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
2711 // @@protoc_insertion_point(field_set_allocated:tensorflow.NamedTupleValue.name)
2712}
2713
2714// repeated .tensorflow.PairValue values = 2;
2715inline int NamedTupleValue::values_size() const {
2716 return values_.size();
2717}
2718inline void NamedTupleValue::clear_values() {
2719 values_.Clear();
2720}
2721inline ::tensorflow::PairValue* NamedTupleValue::mutable_values(int index) {
2722 // @@protoc_insertion_point(field_mutable:tensorflow.NamedTupleValue.values)
2723 return values_.Mutable(index);
2724}
2725inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::PairValue >*
2726NamedTupleValue::mutable_values() {
2727 // @@protoc_insertion_point(field_mutable_list:tensorflow.NamedTupleValue.values)
2728 return &values_;
2729}
2730inline const ::tensorflow::PairValue& NamedTupleValue::values(int index) const {
2731 // @@protoc_insertion_point(field_get:tensorflow.NamedTupleValue.values)
2732 return values_.Get(index);
2733}
2734inline ::tensorflow::PairValue* NamedTupleValue::add_values() {
2735 // @@protoc_insertion_point(field_add:tensorflow.NamedTupleValue.values)
2736 return values_.Add();
2737}
2738inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::PairValue >&
2739NamedTupleValue::values() const {
2740 // @@protoc_insertion_point(field_list:tensorflow.NamedTupleValue.values)
2741 return values_;
2742}
2743
2744// -------------------------------------------------------------------
2745
2746// TensorSpecProto
2747
2748// string name = 1;
2749inline void TensorSpecProto::clear_name() {
2750 name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2751}
2752inline const std::string& TensorSpecProto::name() const {
2753 // @@protoc_insertion_point(field_get:tensorflow.TensorSpecProto.name)
2754 return name_.GetNoArena();
2755}
2756inline void TensorSpecProto::set_name(const std::string& value) {
2757
2758 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2759 // @@protoc_insertion_point(field_set:tensorflow.TensorSpecProto.name)
2760}
2761inline void TensorSpecProto::set_name(std::string&& value) {
2762
2763 name_.SetNoArena(
2764 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2765 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TensorSpecProto.name)
2766}
2767inline void TensorSpecProto::set_name(const char* value) {
2768 GOOGLE_DCHECK(value != nullptr);
2769
2770 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2771 // @@protoc_insertion_point(field_set_char:tensorflow.TensorSpecProto.name)
2772}
2773inline void TensorSpecProto::set_name(const char* value, size_t size) {
2774
2775 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2776 ::std::string(reinterpret_cast<const char*>(value), size));
2777 // @@protoc_insertion_point(field_set_pointer:tensorflow.TensorSpecProto.name)
2778}
2779inline std::string* TensorSpecProto::mutable_name() {
2780
2781 // @@protoc_insertion_point(field_mutable:tensorflow.TensorSpecProto.name)
2782 return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2783}
2784inline std::string* TensorSpecProto::release_name() {
2785 // @@protoc_insertion_point(field_release:tensorflow.TensorSpecProto.name)
2786
2787 return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2788}
2789inline void TensorSpecProto::set_allocated_name(std::string* name) {
2790 if (name != nullptr) {
2791
2792 } else {
2793
2794 }
2795 name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
2796 // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorSpecProto.name)
2797}
2798
2799// .tensorflow.TensorShapeProto shape = 2;
2800inline bool TensorSpecProto::has_shape() const {
2801 return this != internal_default_instance() && shape_ != nullptr;
2802}
2803inline const ::tensorflow::TensorShapeProto& TensorSpecProto::shape() const {
2804 const ::tensorflow::TensorShapeProto* p = shape_;
2805 // @@protoc_insertion_point(field_get:tensorflow.TensorSpecProto.shape)
2806 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::TensorShapeProto*>(
2807 &::tensorflow::_TensorShapeProto_default_instance_);
2808}
2809inline ::tensorflow::TensorShapeProto* TensorSpecProto::release_shape() {
2810 // @@protoc_insertion_point(field_release:tensorflow.TensorSpecProto.shape)
2811
2812 ::tensorflow::TensorShapeProto* temp = shape_;
2813 shape_ = nullptr;
2814 return temp;
2815}
2816inline ::tensorflow::TensorShapeProto* TensorSpecProto::mutable_shape() {
2817
2818 if (shape_ == nullptr) {
2819 auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaNoVirtual());
2820 shape_ = p;
2821 }
2822 // @@protoc_insertion_point(field_mutable:tensorflow.TensorSpecProto.shape)
2823 return shape_;
2824}
2825inline void TensorSpecProto::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
2826 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2827 if (message_arena == nullptr) {
2828 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
2829 }
2830 if (shape) {
2831 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2832 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape)->GetArena();
2833 if (message_arena != submessage_arena) {
2834 shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2835 message_arena, shape, submessage_arena);
2836 }
2837
2838 } else {
2839
2840 }
2841 shape_ = shape;
2842 // @@protoc_insertion_point(field_set_allocated:tensorflow.TensorSpecProto.shape)
2843}
2844
2845// .tensorflow.DataType dtype = 3;
2846inline void TensorSpecProto::clear_dtype() {
2847 dtype_ = 0;
2848}
2849inline ::tensorflow::DataType TensorSpecProto::dtype() const {
2850 // @@protoc_insertion_point(field_get:tensorflow.TensorSpecProto.dtype)
2851 return static_cast< ::tensorflow::DataType >(dtype_);
2852}
2853inline void TensorSpecProto::set_dtype(::tensorflow::DataType value) {
2854
2855 dtype_ = value;
2856 // @@protoc_insertion_point(field_set:tensorflow.TensorSpecProto.dtype)
2857}
2858
2859// -------------------------------------------------------------------
2860
2861// BoundedTensorSpecProto
2862
2863// string name = 1;
2864inline void BoundedTensorSpecProto::clear_name() {
2865 name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2866}
2867inline const std::string& BoundedTensorSpecProto::name() const {
2868 // @@protoc_insertion_point(field_get:tensorflow.BoundedTensorSpecProto.name)
2869 return name_.GetNoArena();
2870}
2871inline void BoundedTensorSpecProto::set_name(const std::string& value) {
2872
2873 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
2874 // @@protoc_insertion_point(field_set:tensorflow.BoundedTensorSpecProto.name)
2875}
2876inline void BoundedTensorSpecProto::set_name(std::string&& value) {
2877
2878 name_.SetNoArena(
2879 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2880 // @@protoc_insertion_point(field_set_rvalue:tensorflow.BoundedTensorSpecProto.name)
2881}
2882inline void BoundedTensorSpecProto::set_name(const char* value) {
2883 GOOGLE_DCHECK(value != nullptr);
2884
2885 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2886 // @@protoc_insertion_point(field_set_char:tensorflow.BoundedTensorSpecProto.name)
2887}
2888inline void BoundedTensorSpecProto::set_name(const char* value, size_t size) {
2889
2890 name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
2891 ::std::string(reinterpret_cast<const char*>(value), size));
2892 // @@protoc_insertion_point(field_set_pointer:tensorflow.BoundedTensorSpecProto.name)
2893}
2894inline std::string* BoundedTensorSpecProto::mutable_name() {
2895
2896 // @@protoc_insertion_point(field_mutable:tensorflow.BoundedTensorSpecProto.name)
2897 return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2898}
2899inline std::string* BoundedTensorSpecProto::release_name() {
2900 // @@protoc_insertion_point(field_release:tensorflow.BoundedTensorSpecProto.name)
2901
2902 return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
2903}
2904inline void BoundedTensorSpecProto::set_allocated_name(std::string* name) {
2905 if (name != nullptr) {
2906
2907 } else {
2908
2909 }
2910 name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
2911 // @@protoc_insertion_point(field_set_allocated:tensorflow.BoundedTensorSpecProto.name)
2912}
2913
2914// .tensorflow.TensorShapeProto shape = 2;
2915inline bool BoundedTensorSpecProto::has_shape() const {
2916 return this != internal_default_instance() && shape_ != nullptr;
2917}
2918inline const ::tensorflow::TensorShapeProto& BoundedTensorSpecProto::shape() const {
2919 const ::tensorflow::TensorShapeProto* p = shape_;
2920 // @@protoc_insertion_point(field_get:tensorflow.BoundedTensorSpecProto.shape)
2921 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::TensorShapeProto*>(
2922 &::tensorflow::_TensorShapeProto_default_instance_);
2923}
2924inline ::tensorflow::TensorShapeProto* BoundedTensorSpecProto::release_shape() {
2925 // @@protoc_insertion_point(field_release:tensorflow.BoundedTensorSpecProto.shape)
2926
2927 ::tensorflow::TensorShapeProto* temp = shape_;
2928 shape_ = nullptr;
2929 return temp;
2930}
2931inline ::tensorflow::TensorShapeProto* BoundedTensorSpecProto::mutable_shape() {
2932
2933 if (shape_ == nullptr) {
2934 auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaNoVirtual());
2935 shape_ = p;
2936 }
2937 // @@protoc_insertion_point(field_mutable:tensorflow.BoundedTensorSpecProto.shape)
2938 return shape_;
2939}
2940inline void BoundedTensorSpecProto::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
2941 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
2942 if (message_arena == nullptr) {
2943 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
2944 }
2945 if (shape) {
2946 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2947 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape)->GetArena();
2948 if (message_arena != submessage_arena) {
2949 shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2950 message_arena, shape, submessage_arena);
2951 }
2952
2953 } else {
2954
2955 }
2956 shape_ = shape;
2957 // @@protoc_insertion_point(field_set_allocated:tensorflow.BoundedTensorSpecProto.shape)
2958}
2959
2960// .tensorflow.DataType dtype = 3;
2961inline void BoundedTensorSpecProto::clear_dtype() {
2962 dtype_ = 0;
2963}
2964inline ::tensorflow::DataType BoundedTensorSpecProto::dtype() const {
2965 // @@protoc_insertion_point(field_get:tensorflow.BoundedTensorSpecProto.dtype)
2966 return static_cast< ::tensorflow::DataType >(dtype_);
2967}
2968inline void BoundedTensorSpecProto::set_dtype(::tensorflow::DataType value) {
2969
2970 dtype_ = value;
2971 // @@protoc_insertion_point(field_set:tensorflow.BoundedTensorSpecProto.dtype)
2972}
2973
2974// .tensorflow.TensorProto minimum = 4;
2975inline bool BoundedTensorSpecProto::has_minimum() const {
2976 return this != internal_default_instance() && minimum_ != nullptr;
2977}
2978inline const ::tensorflow::TensorProto& BoundedTensorSpecProto::minimum() const {
2979 const ::tensorflow::TensorProto* p = minimum_;
2980 // @@protoc_insertion_point(field_get:tensorflow.BoundedTensorSpecProto.minimum)
2981 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::TensorProto*>(
2982 &::tensorflow::_TensorProto_default_instance_);
2983}
2984inline ::tensorflow::TensorProto* BoundedTensorSpecProto::release_minimum() {
2985 // @@protoc_insertion_point(field_release:tensorflow.BoundedTensorSpecProto.minimum)
2986
2987 ::tensorflow::TensorProto* temp = minimum_;
2988 minimum_ = nullptr;
2989 return temp;
2990}
2991inline ::tensorflow::TensorProto* BoundedTensorSpecProto::mutable_minimum() {
2992
2993 if (minimum_ == nullptr) {
2994 auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaNoVirtual());
2995 minimum_ = p;
2996 }
2997 // @@protoc_insertion_point(field_mutable:tensorflow.BoundedTensorSpecProto.minimum)
2998 return minimum_;
2999}
3000inline void BoundedTensorSpecProto::set_allocated_minimum(::tensorflow::TensorProto* minimum) {
3001 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3002 if (message_arena == nullptr) {
3003 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(minimum_);
3004 }
3005 if (minimum) {
3006 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3007 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(minimum)->GetArena();
3008 if (message_arena != submessage_arena) {
3009 minimum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3010 message_arena, minimum, submessage_arena);
3011 }
3012
3013 } else {
3014
3015 }
3016 minimum_ = minimum;
3017 // @@protoc_insertion_point(field_set_allocated:tensorflow.BoundedTensorSpecProto.minimum)
3018}
3019
3020// .tensorflow.TensorProto maximum = 5;
3021inline bool BoundedTensorSpecProto::has_maximum() const {
3022 return this != internal_default_instance() && maximum_ != nullptr;
3023}
3024inline const ::tensorflow::TensorProto& BoundedTensorSpecProto::maximum() const {
3025 const ::tensorflow::TensorProto* p = maximum_;
3026 // @@protoc_insertion_point(field_get:tensorflow.BoundedTensorSpecProto.maximum)
3027 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::TensorProto*>(
3028 &::tensorflow::_TensorProto_default_instance_);
3029}
3030inline ::tensorflow::TensorProto* BoundedTensorSpecProto::release_maximum() {
3031 // @@protoc_insertion_point(field_release:tensorflow.BoundedTensorSpecProto.maximum)
3032
3033 ::tensorflow::TensorProto* temp = maximum_;
3034 maximum_ = nullptr;
3035 return temp;
3036}
3037inline ::tensorflow::TensorProto* BoundedTensorSpecProto::mutable_maximum() {
3038
3039 if (maximum_ == nullptr) {
3040 auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaNoVirtual());
3041 maximum_ = p;
3042 }
3043 // @@protoc_insertion_point(field_mutable:tensorflow.BoundedTensorSpecProto.maximum)
3044 return maximum_;
3045}
3046inline void BoundedTensorSpecProto::set_allocated_maximum(::tensorflow::TensorProto* maximum) {
3047 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3048 if (message_arena == nullptr) {
3049 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(maximum_);
3050 }
3051 if (maximum) {
3052 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3053 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(maximum)->GetArena();
3054 if (message_arena != submessage_arena) {
3055 maximum = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3056 message_arena, maximum, submessage_arena);
3057 }
3058
3059 } else {
3060
3061 }
3062 maximum_ = maximum;
3063 // @@protoc_insertion_point(field_set_allocated:tensorflow.BoundedTensorSpecProto.maximum)
3064}
3065
3066// -------------------------------------------------------------------
3067
3068// TypeSpecProto
3069
3070// .tensorflow.TypeSpecProto.TypeSpecClass type_spec_class = 1;
3071inline void TypeSpecProto::clear_type_spec_class() {
3072 type_spec_class_ = 0;
3073}
3074inline ::tensorflow::TypeSpecProto_TypeSpecClass TypeSpecProto::type_spec_class() const {
3075 // @@protoc_insertion_point(field_get:tensorflow.TypeSpecProto.type_spec_class)
3076 return static_cast< ::tensorflow::TypeSpecProto_TypeSpecClass >(type_spec_class_);
3077}
3078inline void TypeSpecProto::set_type_spec_class(::tensorflow::TypeSpecProto_TypeSpecClass value) {
3079
3080 type_spec_class_ = value;
3081 // @@protoc_insertion_point(field_set:tensorflow.TypeSpecProto.type_spec_class)
3082}
3083
3084// .tensorflow.StructuredValue type_state = 2;
3085inline bool TypeSpecProto::has_type_state() const {
3086 return this != internal_default_instance() && type_state_ != nullptr;
3087}
3088inline void TypeSpecProto::clear_type_state() {
3089 if (GetArenaNoVirtual() == nullptr && type_state_ != nullptr) {
3090 delete type_state_;
3091 }
3092 type_state_ = nullptr;
3093}
3094inline const ::tensorflow::StructuredValue& TypeSpecProto::type_state() const {
3095 const ::tensorflow::StructuredValue* p = type_state_;
3096 // @@protoc_insertion_point(field_get:tensorflow.TypeSpecProto.type_state)
3097 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::StructuredValue*>(
3098 &::tensorflow::_StructuredValue_default_instance_);
3099}
3100inline ::tensorflow::StructuredValue* TypeSpecProto::release_type_state() {
3101 // @@protoc_insertion_point(field_release:tensorflow.TypeSpecProto.type_state)
3102
3103 ::tensorflow::StructuredValue* temp = type_state_;
3104 type_state_ = nullptr;
3105 return temp;
3106}
3107inline ::tensorflow::StructuredValue* TypeSpecProto::mutable_type_state() {
3108
3109 if (type_state_ == nullptr) {
3110 auto* p = CreateMaybeMessage<::tensorflow::StructuredValue>(GetArenaNoVirtual());
3111 type_state_ = p;
3112 }
3113 // @@protoc_insertion_point(field_mutable:tensorflow.TypeSpecProto.type_state)
3114 return type_state_;
3115}
3116inline void TypeSpecProto::set_allocated_type_state(::tensorflow::StructuredValue* type_state) {
3117 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3118 if (message_arena == nullptr) {
3119 delete type_state_;
3120 }
3121 if (type_state) {
3122 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
3123 if (message_arena != submessage_arena) {
3124 type_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3125 message_arena, type_state, submessage_arena);
3126 }
3127
3128 } else {
3129
3130 }
3131 type_state_ = type_state;
3132 // @@protoc_insertion_point(field_set_allocated:tensorflow.TypeSpecProto.type_state)
3133}
3134
3135// string type_spec_class_name = 3;
3136inline void TypeSpecProto::clear_type_spec_class_name() {
3137 type_spec_class_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3138}
3139inline const std::string& TypeSpecProto::type_spec_class_name() const {
3140 // @@protoc_insertion_point(field_get:tensorflow.TypeSpecProto.type_spec_class_name)
3141 return type_spec_class_name_.GetNoArena();
3142}
3143inline void TypeSpecProto::set_type_spec_class_name(const std::string& value) {
3144
3145 type_spec_class_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
3146 // @@protoc_insertion_point(field_set:tensorflow.TypeSpecProto.type_spec_class_name)
3147}
3148inline void TypeSpecProto::set_type_spec_class_name(std::string&& value) {
3149
3150 type_spec_class_name_.SetNoArena(
3151 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3152 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TypeSpecProto.type_spec_class_name)
3153}
3154inline void TypeSpecProto::set_type_spec_class_name(const char* value) {
3155 GOOGLE_DCHECK(value != nullptr);
3156
3157 type_spec_class_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3158 // @@protoc_insertion_point(field_set_char:tensorflow.TypeSpecProto.type_spec_class_name)
3159}
3160inline void TypeSpecProto::set_type_spec_class_name(const char* value, size_t size) {
3161
3162 type_spec_class_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3163 ::std::string(reinterpret_cast<const char*>(value), size));
3164 // @@protoc_insertion_point(field_set_pointer:tensorflow.TypeSpecProto.type_spec_class_name)
3165}
3166inline std::string* TypeSpecProto::mutable_type_spec_class_name() {
3167
3168 // @@protoc_insertion_point(field_mutable:tensorflow.TypeSpecProto.type_spec_class_name)
3169 return type_spec_class_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3170}
3171inline std::string* TypeSpecProto::release_type_spec_class_name() {
3172 // @@protoc_insertion_point(field_release:tensorflow.TypeSpecProto.type_spec_class_name)
3173
3174 return type_spec_class_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3175}
3176inline void TypeSpecProto::set_allocated_type_spec_class_name(std::string* type_spec_class_name) {
3177 if (type_spec_class_name != nullptr) {
3178
3179 } else {
3180
3181 }
3182 type_spec_class_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type_spec_class_name);
3183 // @@protoc_insertion_point(field_set_allocated:tensorflow.TypeSpecProto.type_spec_class_name)
3184}
3185
3186// int32 num_flat_components = 4;
3187inline void TypeSpecProto::clear_num_flat_components() {
3188 num_flat_components_ = 0;
3189}
3190inline ::PROTOBUF_NAMESPACE_ID::int32 TypeSpecProto::num_flat_components() const {
3191 // @@protoc_insertion_point(field_get:tensorflow.TypeSpecProto.num_flat_components)
3192 return num_flat_components_;
3193}
3194inline void TypeSpecProto::set_num_flat_components(::PROTOBUF_NAMESPACE_ID::int32 value) {
3195
3196 num_flat_components_ = value;
3197 // @@protoc_insertion_point(field_set:tensorflow.TypeSpecProto.num_flat_components)
3198}
3199
3200#ifdef __GNUC__
3201 #pragma GCC diagnostic pop
3202#endif // __GNUC__
3203// -------------------------------------------------------------------
3204
3205// -------------------------------------------------------------------
3206
3207// -------------------------------------------------------------------
3208
3209// -------------------------------------------------------------------
3210
3211// -------------------------------------------------------------------
3212
3213// -------------------------------------------------------------------
3214
3215// -------------------------------------------------------------------
3216
3217// -------------------------------------------------------------------
3218
3219// -------------------------------------------------------------------
3220
3221// -------------------------------------------------------------------
3222
3223
3224// @@protoc_insertion_point(namespace_scope)
3225
3226} // namespace tensorflow
3227
3228PROTOBUF_NAMESPACE_OPEN
3229
3230template <> struct is_proto_enum< ::tensorflow::TypeSpecProto_TypeSpecClass> : ::std::true_type {};
3231template <>
3232inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::TypeSpecProto_TypeSpecClass>() {
3233 return ::tensorflow::TypeSpecProto_TypeSpecClass_descriptor();
3234}
3235
3236PROTOBUF_NAMESPACE_CLOSE
3237
3238// @@protoc_insertion_point(global_scope)
3239
3240#include <google/protobuf/port_undef.inc>
3241#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fstruct_2eproto
3242