1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/data_service.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_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/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36// @@protoc_insertion_point(includes)
37#include <google/protobuf/port_def.inc>
38#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto
39PROTOBUF_NAMESPACE_OPEN
40namespace internal {
41class AnyMetadata;
42} // namespace internal
43PROTOBUF_NAMESPACE_CLOSE
44
45// Internal implementation detail -- do not use these members.
46struct TableStruct_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto {
47 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
48 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
49 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
52 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
54 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
55 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
56};
57extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto;
58namespace tensorflow {
59namespace data {
60class CrossTrainerCacheOptions;
61class CrossTrainerCacheOptionsDefaultTypeInternal;
62extern CrossTrainerCacheOptionsDefaultTypeInternal _CrossTrainerCacheOptions_default_instance_;
63class DataServiceConfig;
64class DataServiceConfigDefaultTypeInternal;
65extern DataServiceConfigDefaultTypeInternal _DataServiceConfig_default_instance_;
66class DataServiceMetadata;
67class DataServiceMetadataDefaultTypeInternal;
68extern DataServiceMetadataDefaultTypeInternal _DataServiceMetadata_default_instance_;
69class ProcessingModeDef;
70class ProcessingModeDefDefaultTypeInternal;
71extern ProcessingModeDefDefaultTypeInternal _ProcessingModeDef_default_instance_;
72} // namespace data
73} // namespace tensorflow
74PROTOBUF_NAMESPACE_OPEN
75template<> ::tensorflow::data::CrossTrainerCacheOptions* Arena::CreateMaybeMessage<::tensorflow::data::CrossTrainerCacheOptions>(Arena*);
76template<> ::tensorflow::data::DataServiceConfig* Arena::CreateMaybeMessage<::tensorflow::data::DataServiceConfig>(Arena*);
77template<> ::tensorflow::data::DataServiceMetadata* Arena::CreateMaybeMessage<::tensorflow::data::DataServiceMetadata>(Arena*);
78template<> ::tensorflow::data::ProcessingModeDef* Arena::CreateMaybeMessage<::tensorflow::data::ProcessingModeDef>(Arena*);
79PROTOBUF_NAMESPACE_CLOSE
80namespace tensorflow {
81namespace data {
82
83enum ProcessingModeDef_ShardingPolicy : int {
84 ProcessingModeDef_ShardingPolicy_OFF = 0,
85 ProcessingModeDef_ShardingPolicy_DYNAMIC = 1,
86 ProcessingModeDef_ShardingPolicy_FILE = 2,
87 ProcessingModeDef_ShardingPolicy_DATA = 3,
88 ProcessingModeDef_ShardingPolicy_FILE_OR_DATA = 4,
89 ProcessingModeDef_ShardingPolicy_HINT = 5,
90 ProcessingModeDef_ShardingPolicy_ProcessingModeDef_ShardingPolicy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
91 ProcessingModeDef_ShardingPolicy_ProcessingModeDef_ShardingPolicy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
92};
93bool ProcessingModeDef_ShardingPolicy_IsValid(int value);
94constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef_ShardingPolicy_ShardingPolicy_MIN = ProcessingModeDef_ShardingPolicy_OFF;
95constexpr ProcessingModeDef_ShardingPolicy ProcessingModeDef_ShardingPolicy_ShardingPolicy_MAX = ProcessingModeDef_ShardingPolicy_HINT;
96constexpr int ProcessingModeDef_ShardingPolicy_ShardingPolicy_ARRAYSIZE = ProcessingModeDef_ShardingPolicy_ShardingPolicy_MAX + 1;
97
98const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProcessingModeDef_ShardingPolicy_descriptor();
99template<typename T>
100inline const std::string& ProcessingModeDef_ShardingPolicy_Name(T enum_t_value) {
101 static_assert(::std::is_same<T, ProcessingModeDef_ShardingPolicy>::value ||
102 ::std::is_integral<T>::value,
103 "Incorrect type passed to function ProcessingModeDef_ShardingPolicy_Name.");
104 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
105 ProcessingModeDef_ShardingPolicy_descriptor(), enum_t_value);
106}
107inline bool ProcessingModeDef_ShardingPolicy_Parse(
108 const std::string& name, ProcessingModeDef_ShardingPolicy* value) {
109 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProcessingModeDef_ShardingPolicy>(
110 ProcessingModeDef_ShardingPolicy_descriptor(), name, value);
111}
112enum DataServiceMetadata_Compression : int {
113 DataServiceMetadata_Compression_COMPRESSION_UNSPECIFIED = 0,
114 DataServiceMetadata_Compression_COMPRESSION_OFF = 1,
115 DataServiceMetadata_Compression_COMPRESSION_SNAPPY = 2,
116 DataServiceMetadata_Compression_DataServiceMetadata_Compression_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
117 DataServiceMetadata_Compression_DataServiceMetadata_Compression_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
118};
119bool DataServiceMetadata_Compression_IsValid(int value);
120constexpr DataServiceMetadata_Compression DataServiceMetadata_Compression_Compression_MIN = DataServiceMetadata_Compression_COMPRESSION_UNSPECIFIED;
121constexpr DataServiceMetadata_Compression DataServiceMetadata_Compression_Compression_MAX = DataServiceMetadata_Compression_COMPRESSION_SNAPPY;
122constexpr int DataServiceMetadata_Compression_Compression_ARRAYSIZE = DataServiceMetadata_Compression_Compression_MAX + 1;
123
124const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataServiceMetadata_Compression_descriptor();
125template<typename T>
126inline const std::string& DataServiceMetadata_Compression_Name(T enum_t_value) {
127 static_assert(::std::is_same<T, DataServiceMetadata_Compression>::value ||
128 ::std::is_integral<T>::value,
129 "Incorrect type passed to function DataServiceMetadata_Compression_Name.");
130 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
131 DataServiceMetadata_Compression_descriptor(), enum_t_value);
132}
133inline bool DataServiceMetadata_Compression_Parse(
134 const std::string& name, DataServiceMetadata_Compression* value) {
135 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DataServiceMetadata_Compression>(
136 DataServiceMetadata_Compression_descriptor(), name, value);
137}
138enum DeploymentMode : int {
139 DEPLOYMENT_MODE_UNSPECIFIED = 0,
140 DEPLOYMENT_MODE_COLOCATED = 1,
141 DEPLOYMENT_MODE_REMOTE = 2,
142 DEPLOYMENT_MODE_HYBRID = 3,
143 DeploymentMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
144 DeploymentMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
145};
146bool DeploymentMode_IsValid(int value);
147constexpr DeploymentMode DeploymentMode_MIN = DEPLOYMENT_MODE_UNSPECIFIED;
148constexpr DeploymentMode DeploymentMode_MAX = DEPLOYMENT_MODE_HYBRID;
149constexpr int DeploymentMode_ARRAYSIZE = DeploymentMode_MAX + 1;
150
151const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeploymentMode_descriptor();
152template<typename T>
153inline const std::string& DeploymentMode_Name(T enum_t_value) {
154 static_assert(::std::is_same<T, DeploymentMode>::value ||
155 ::std::is_integral<T>::value,
156 "Incorrect type passed to function DeploymentMode_Name.");
157 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
158 DeploymentMode_descriptor(), enum_t_value);
159}
160inline bool DeploymentMode_Parse(
161 const std::string& name, DeploymentMode* value) {
162 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeploymentMode>(
163 DeploymentMode_descriptor(), name, value);
164}
165// ===================================================================
166
167class ProcessingModeDef :
168 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.ProcessingModeDef) */ {
169 public:
170 ProcessingModeDef();
171 virtual ~ProcessingModeDef();
172
173 ProcessingModeDef(const ProcessingModeDef& from);
174 ProcessingModeDef(ProcessingModeDef&& from) noexcept
175 : ProcessingModeDef() {
176 *this = ::std::move(from);
177 }
178
179 inline ProcessingModeDef& operator=(const ProcessingModeDef& from) {
180 CopyFrom(from);
181 return *this;
182 }
183 inline ProcessingModeDef& operator=(ProcessingModeDef&& from) noexcept {
184 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
185 if (this != &from) InternalSwap(&from);
186 } else {
187 CopyFrom(from);
188 }
189 return *this;
190 }
191
192 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
193 return GetDescriptor();
194 }
195 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
196 return GetMetadataStatic().descriptor;
197 }
198 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
199 return GetMetadataStatic().reflection;
200 }
201 static const ProcessingModeDef& default_instance();
202
203 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
204 static inline const ProcessingModeDef* internal_default_instance() {
205 return reinterpret_cast<const ProcessingModeDef*>(
206 &_ProcessingModeDef_default_instance_);
207 }
208 static constexpr int kIndexInFileMessages =
209 0;
210
211 friend void swap(ProcessingModeDef& a, ProcessingModeDef& b) {
212 a.Swap(&b);
213 }
214 inline void Swap(ProcessingModeDef* other) {
215 if (other == this) return;
216 InternalSwap(other);
217 }
218
219 // implements Message ----------------------------------------------
220
221 inline ProcessingModeDef* New() const final {
222 return CreateMaybeMessage<ProcessingModeDef>(nullptr);
223 }
224
225 ProcessingModeDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
226 return CreateMaybeMessage<ProcessingModeDef>(arena);
227 }
228 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
229 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
230 void CopyFrom(const ProcessingModeDef& from);
231 void MergeFrom(const ProcessingModeDef& from);
232 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
233 bool IsInitialized() const final;
234
235 size_t ByteSizeLong() const final;
236 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
237 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
238 #else
239 bool MergePartialFromCodedStream(
240 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
241 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
242 void SerializeWithCachedSizes(
243 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
244 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
245 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
246 int GetCachedSize() const final { return _cached_size_.Get(); }
247
248 private:
249 inline void SharedCtor();
250 inline void SharedDtor();
251 void SetCachedSize(int size) const final;
252 void InternalSwap(ProcessingModeDef* other);
253 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
254 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
255 return "tensorflow.data.ProcessingModeDef";
256 }
257 private:
258 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
259 return nullptr;
260 }
261 inline void* MaybeArenaPtr() const {
262 return nullptr;
263 }
264 public:
265
266 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
267 private:
268 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
269 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto);
270 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
271 }
272
273 public:
274
275 // nested types ----------------------------------------------------
276
277 typedef ProcessingModeDef_ShardingPolicy ShardingPolicy;
278 static constexpr ShardingPolicy OFF =
279 ProcessingModeDef_ShardingPolicy_OFF;
280 static constexpr ShardingPolicy DYNAMIC =
281 ProcessingModeDef_ShardingPolicy_DYNAMIC;
282 static constexpr ShardingPolicy FILE =
283 ProcessingModeDef_ShardingPolicy_FILE;
284 static constexpr ShardingPolicy DATA =
285 ProcessingModeDef_ShardingPolicy_DATA;
286 static constexpr ShardingPolicy FILE_OR_DATA =
287 ProcessingModeDef_ShardingPolicy_FILE_OR_DATA;
288 static constexpr ShardingPolicy HINT =
289 ProcessingModeDef_ShardingPolicy_HINT;
290 static inline bool ShardingPolicy_IsValid(int value) {
291 return ProcessingModeDef_ShardingPolicy_IsValid(value);
292 }
293 static constexpr ShardingPolicy ShardingPolicy_MIN =
294 ProcessingModeDef_ShardingPolicy_ShardingPolicy_MIN;
295 static constexpr ShardingPolicy ShardingPolicy_MAX =
296 ProcessingModeDef_ShardingPolicy_ShardingPolicy_MAX;
297 static constexpr int ShardingPolicy_ARRAYSIZE =
298 ProcessingModeDef_ShardingPolicy_ShardingPolicy_ARRAYSIZE;
299 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
300 ShardingPolicy_descriptor() {
301 return ProcessingModeDef_ShardingPolicy_descriptor();
302 }
303 template<typename T>
304 static inline const std::string& ShardingPolicy_Name(T enum_t_value) {
305 static_assert(::std::is_same<T, ShardingPolicy>::value ||
306 ::std::is_integral<T>::value,
307 "Incorrect type passed to function ShardingPolicy_Name.");
308 return ProcessingModeDef_ShardingPolicy_Name(enum_t_value);
309 }
310 static inline bool ShardingPolicy_Parse(const std::string& name,
311 ShardingPolicy* value) {
312 return ProcessingModeDef_ShardingPolicy_Parse(name, value);
313 }
314
315 // accessors -------------------------------------------------------
316
317 enum : int {
318 kShardingPolicyFieldNumber = 1,
319 };
320 // .tensorflow.data.ProcessingModeDef.ShardingPolicy sharding_policy = 1;
321 void clear_sharding_policy();
322 ::tensorflow::data::ProcessingModeDef_ShardingPolicy sharding_policy() const;
323 void set_sharding_policy(::tensorflow::data::ProcessingModeDef_ShardingPolicy value);
324
325 // @@protoc_insertion_point(class_scope:tensorflow.data.ProcessingModeDef)
326 private:
327 class _Internal;
328
329 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
330 int sharding_policy_;
331 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
332 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto;
333};
334// -------------------------------------------------------------------
335
336class DataServiceMetadata :
337 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.DataServiceMetadata) */ {
338 public:
339 DataServiceMetadata();
340 virtual ~DataServiceMetadata();
341
342 DataServiceMetadata(const DataServiceMetadata& from);
343 DataServiceMetadata(DataServiceMetadata&& from) noexcept
344 : DataServiceMetadata() {
345 *this = ::std::move(from);
346 }
347
348 inline DataServiceMetadata& operator=(const DataServiceMetadata& from) {
349 CopyFrom(from);
350 return *this;
351 }
352 inline DataServiceMetadata& operator=(DataServiceMetadata&& from) noexcept {
353 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
354 if (this != &from) InternalSwap(&from);
355 } else {
356 CopyFrom(from);
357 }
358 return *this;
359 }
360
361 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
362 return GetDescriptor();
363 }
364 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
365 return GetMetadataStatic().descriptor;
366 }
367 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
368 return GetMetadataStatic().reflection;
369 }
370 static const DataServiceMetadata& default_instance();
371
372 enum OptionalElementSpecCase {
373 kElementSpec = 1,
374 OPTIONAL_ELEMENT_SPEC_NOT_SET = 0,
375 };
376
377 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
378 static inline const DataServiceMetadata* internal_default_instance() {
379 return reinterpret_cast<const DataServiceMetadata*>(
380 &_DataServiceMetadata_default_instance_);
381 }
382 static constexpr int kIndexInFileMessages =
383 1;
384
385 friend void swap(DataServiceMetadata& a, DataServiceMetadata& b) {
386 a.Swap(&b);
387 }
388 inline void Swap(DataServiceMetadata* other) {
389 if (other == this) return;
390 InternalSwap(other);
391 }
392
393 // implements Message ----------------------------------------------
394
395 inline DataServiceMetadata* New() const final {
396 return CreateMaybeMessage<DataServiceMetadata>(nullptr);
397 }
398
399 DataServiceMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
400 return CreateMaybeMessage<DataServiceMetadata>(arena);
401 }
402 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
403 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
404 void CopyFrom(const DataServiceMetadata& from);
405 void MergeFrom(const DataServiceMetadata& from);
406 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
407 bool IsInitialized() const final;
408
409 size_t ByteSizeLong() const final;
410 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
411 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
412 #else
413 bool MergePartialFromCodedStream(
414 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
415 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
416 void SerializeWithCachedSizes(
417 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
418 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
419 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
420 int GetCachedSize() const final { return _cached_size_.Get(); }
421
422 private:
423 inline void SharedCtor();
424 inline void SharedDtor();
425 void SetCachedSize(int size) const final;
426 void InternalSwap(DataServiceMetadata* other);
427 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
428 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
429 return "tensorflow.data.DataServiceMetadata";
430 }
431 private:
432 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
433 return nullptr;
434 }
435 inline void* MaybeArenaPtr() const {
436 return nullptr;
437 }
438 public:
439
440 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
441 private:
442 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
443 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto);
444 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
445 }
446
447 public:
448
449 // nested types ----------------------------------------------------
450
451 typedef DataServiceMetadata_Compression Compression;
452 static constexpr Compression COMPRESSION_UNSPECIFIED =
453 DataServiceMetadata_Compression_COMPRESSION_UNSPECIFIED;
454 static constexpr Compression COMPRESSION_OFF =
455 DataServiceMetadata_Compression_COMPRESSION_OFF;
456 static constexpr Compression COMPRESSION_SNAPPY =
457 DataServiceMetadata_Compression_COMPRESSION_SNAPPY;
458 static inline bool Compression_IsValid(int value) {
459 return DataServiceMetadata_Compression_IsValid(value);
460 }
461 static constexpr Compression Compression_MIN =
462 DataServiceMetadata_Compression_Compression_MIN;
463 static constexpr Compression Compression_MAX =
464 DataServiceMetadata_Compression_Compression_MAX;
465 static constexpr int Compression_ARRAYSIZE =
466 DataServiceMetadata_Compression_Compression_ARRAYSIZE;
467 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
468 Compression_descriptor() {
469 return DataServiceMetadata_Compression_descriptor();
470 }
471 template<typename T>
472 static inline const std::string& Compression_Name(T enum_t_value) {
473 static_assert(::std::is_same<T, Compression>::value ||
474 ::std::is_integral<T>::value,
475 "Incorrect type passed to function Compression_Name.");
476 return DataServiceMetadata_Compression_Name(enum_t_value);
477 }
478 static inline bool Compression_Parse(const std::string& name,
479 Compression* value) {
480 return DataServiceMetadata_Compression_Parse(name, value);
481 }
482
483 // accessors -------------------------------------------------------
484
485 enum : int {
486 kCardinalityFieldNumber = 3,
487 kCompressionFieldNumber = 2,
488 kElementSpecFieldNumber = 1,
489 };
490 // int64 cardinality = 3;
491 void clear_cardinality();
492 ::PROTOBUF_NAMESPACE_ID::int64 cardinality() const;
493 void set_cardinality(::PROTOBUF_NAMESPACE_ID::int64 value);
494
495 // .tensorflow.data.DataServiceMetadata.Compression compression = 2;
496 void clear_compression();
497 ::tensorflow::data::DataServiceMetadata_Compression compression() const;
498 void set_compression(::tensorflow::data::DataServiceMetadata_Compression value);
499
500 // bytes element_spec = 1;
501 private:
502 bool has_element_spec() const;
503 public:
504 void clear_element_spec();
505 const std::string& element_spec() const;
506 void set_element_spec(const std::string& value);
507 void set_element_spec(std::string&& value);
508 void set_element_spec(const char* value);
509 void set_element_spec(const void* value, size_t size);
510 std::string* mutable_element_spec();
511 std::string* release_element_spec();
512 void set_allocated_element_spec(std::string* element_spec);
513
514 void clear_optional_element_spec();
515 OptionalElementSpecCase optional_element_spec_case() const;
516 // @@protoc_insertion_point(class_scope:tensorflow.data.DataServiceMetadata)
517 private:
518 class _Internal;
519 void set_has_element_spec();
520
521 inline bool has_optional_element_spec() const;
522 inline void clear_has_optional_element_spec();
523
524 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
525 ::PROTOBUF_NAMESPACE_ID::int64 cardinality_;
526 int compression_;
527 union OptionalElementSpecUnion {
528 OptionalElementSpecUnion() {}
529 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr element_spec_;
530 } optional_element_spec_;
531 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
532 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
533
534 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto;
535};
536// -------------------------------------------------------------------
537
538class CrossTrainerCacheOptions :
539 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CrossTrainerCacheOptions) */ {
540 public:
541 CrossTrainerCacheOptions();
542 virtual ~CrossTrainerCacheOptions();
543
544 CrossTrainerCacheOptions(const CrossTrainerCacheOptions& from);
545 CrossTrainerCacheOptions(CrossTrainerCacheOptions&& from) noexcept
546 : CrossTrainerCacheOptions() {
547 *this = ::std::move(from);
548 }
549
550 inline CrossTrainerCacheOptions& operator=(const CrossTrainerCacheOptions& from) {
551 CopyFrom(from);
552 return *this;
553 }
554 inline CrossTrainerCacheOptions& operator=(CrossTrainerCacheOptions&& from) noexcept {
555 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
556 if (this != &from) InternalSwap(&from);
557 } else {
558 CopyFrom(from);
559 }
560 return *this;
561 }
562
563 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
564 return GetDescriptor();
565 }
566 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
567 return GetMetadataStatic().descriptor;
568 }
569 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
570 return GetMetadataStatic().reflection;
571 }
572 static const CrossTrainerCacheOptions& default_instance();
573
574 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
575 static inline const CrossTrainerCacheOptions* internal_default_instance() {
576 return reinterpret_cast<const CrossTrainerCacheOptions*>(
577 &_CrossTrainerCacheOptions_default_instance_);
578 }
579 static constexpr int kIndexInFileMessages =
580 2;
581
582 friend void swap(CrossTrainerCacheOptions& a, CrossTrainerCacheOptions& b) {
583 a.Swap(&b);
584 }
585 inline void Swap(CrossTrainerCacheOptions* other) {
586 if (other == this) return;
587 InternalSwap(other);
588 }
589
590 // implements Message ----------------------------------------------
591
592 inline CrossTrainerCacheOptions* New() const final {
593 return CreateMaybeMessage<CrossTrainerCacheOptions>(nullptr);
594 }
595
596 CrossTrainerCacheOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
597 return CreateMaybeMessage<CrossTrainerCacheOptions>(arena);
598 }
599 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
600 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
601 void CopyFrom(const CrossTrainerCacheOptions& from);
602 void MergeFrom(const CrossTrainerCacheOptions& from);
603 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
604 bool IsInitialized() const final;
605
606 size_t ByteSizeLong() const final;
607 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
608 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
609 #else
610 bool MergePartialFromCodedStream(
611 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
612 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
613 void SerializeWithCachedSizes(
614 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
615 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
616 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
617 int GetCachedSize() const final { return _cached_size_.Get(); }
618
619 private:
620 inline void SharedCtor();
621 inline void SharedDtor();
622 void SetCachedSize(int size) const final;
623 void InternalSwap(CrossTrainerCacheOptions* other);
624 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
625 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
626 return "tensorflow.data.CrossTrainerCacheOptions";
627 }
628 private:
629 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
630 return nullptr;
631 }
632 inline void* MaybeArenaPtr() const {
633 return nullptr;
634 }
635 public:
636
637 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
638 private:
639 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
640 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto);
641 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
642 }
643
644 public:
645
646 // nested types ----------------------------------------------------
647
648 // accessors -------------------------------------------------------
649
650 enum : int {
651 kTrainerIdFieldNumber = 1,
652 };
653 // string trainer_id = 1;
654 void clear_trainer_id();
655 const std::string& trainer_id() const;
656 void set_trainer_id(const std::string& value);
657 void set_trainer_id(std::string&& value);
658 void set_trainer_id(const char* value);
659 void set_trainer_id(const char* value, size_t size);
660 std::string* mutable_trainer_id();
661 std::string* release_trainer_id();
662 void set_allocated_trainer_id(std::string* trainer_id);
663
664 // @@protoc_insertion_point(class_scope:tensorflow.data.CrossTrainerCacheOptions)
665 private:
666 class _Internal;
667
668 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
669 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trainer_id_;
670 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
671 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto;
672};
673// -------------------------------------------------------------------
674
675class DataServiceConfig :
676 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.DataServiceConfig) */ {
677 public:
678 DataServiceConfig();
679 virtual ~DataServiceConfig();
680
681 DataServiceConfig(const DataServiceConfig& from);
682 DataServiceConfig(DataServiceConfig&& from) noexcept
683 : DataServiceConfig() {
684 *this = ::std::move(from);
685 }
686
687 inline DataServiceConfig& operator=(const DataServiceConfig& from) {
688 CopyFrom(from);
689 return *this;
690 }
691 inline DataServiceConfig& operator=(DataServiceConfig&& from) noexcept {
692 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
693 if (this != &from) InternalSwap(&from);
694 } else {
695 CopyFrom(from);
696 }
697 return *this;
698 }
699
700 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
701 return GetDescriptor();
702 }
703 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
704 return GetMetadataStatic().descriptor;
705 }
706 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
707 return GetMetadataStatic().reflection;
708 }
709 static const DataServiceConfig& default_instance();
710
711 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
712 static inline const DataServiceConfig* internal_default_instance() {
713 return reinterpret_cast<const DataServiceConfig*>(
714 &_DataServiceConfig_default_instance_);
715 }
716 static constexpr int kIndexInFileMessages =
717 3;
718
719 friend void swap(DataServiceConfig& a, DataServiceConfig& b) {
720 a.Swap(&b);
721 }
722 inline void Swap(DataServiceConfig* other) {
723 if (other == this) return;
724 InternalSwap(other);
725 }
726
727 // implements Message ----------------------------------------------
728
729 inline DataServiceConfig* New() const final {
730 return CreateMaybeMessage<DataServiceConfig>(nullptr);
731 }
732
733 DataServiceConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
734 return CreateMaybeMessage<DataServiceConfig>(arena);
735 }
736 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
737 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
738 void CopyFrom(const DataServiceConfig& from);
739 void MergeFrom(const DataServiceConfig& from);
740 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
741 bool IsInitialized() const final;
742
743 size_t ByteSizeLong() const final;
744 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
745 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
746 #else
747 bool MergePartialFromCodedStream(
748 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
749 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
750 void SerializeWithCachedSizes(
751 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
752 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
753 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
754 int GetCachedSize() const final { return _cached_size_.Get(); }
755
756 private:
757 inline void SharedCtor();
758 inline void SharedDtor();
759 void SetCachedSize(int size) const final;
760 void InternalSwap(DataServiceConfig* other);
761 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
762 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
763 return "tensorflow.data.DataServiceConfig";
764 }
765 private:
766 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
767 return nullptr;
768 }
769 inline void* MaybeArenaPtr() const {
770 return nullptr;
771 }
772 public:
773
774 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
775 private:
776 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
777 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto);
778 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
779 }
780
781 public:
782
783 // nested types ----------------------------------------------------
784
785 // accessors -------------------------------------------------------
786
787 enum : int {
788 kDeploymentModeFieldNumber = 1,
789 };
790 // .tensorflow.data.DeploymentMode deployment_mode = 1;
791 void clear_deployment_mode();
792 ::tensorflow::data::DeploymentMode deployment_mode() const;
793 void set_deployment_mode(::tensorflow::data::DeploymentMode value);
794
795 // @@protoc_insertion_point(class_scope:tensorflow.data.DataServiceConfig)
796 private:
797 class _Internal;
798
799 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
800 int deployment_mode_;
801 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
802 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto;
803};
804// ===================================================================
805
806
807// ===================================================================
808
809#ifdef __GNUC__
810 #pragma GCC diagnostic push
811 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
812#endif // __GNUC__
813// ProcessingModeDef
814
815// .tensorflow.data.ProcessingModeDef.ShardingPolicy sharding_policy = 1;
816inline void ProcessingModeDef::clear_sharding_policy() {
817 sharding_policy_ = 0;
818}
819inline ::tensorflow::data::ProcessingModeDef_ShardingPolicy ProcessingModeDef::sharding_policy() const {
820 // @@protoc_insertion_point(field_get:tensorflow.data.ProcessingModeDef.sharding_policy)
821 return static_cast< ::tensorflow::data::ProcessingModeDef_ShardingPolicy >(sharding_policy_);
822}
823inline void ProcessingModeDef::set_sharding_policy(::tensorflow::data::ProcessingModeDef_ShardingPolicy value) {
824
825 sharding_policy_ = value;
826 // @@protoc_insertion_point(field_set:tensorflow.data.ProcessingModeDef.sharding_policy)
827}
828
829// -------------------------------------------------------------------
830
831// DataServiceMetadata
832
833// bytes element_spec = 1;
834inline bool DataServiceMetadata::has_element_spec() const {
835 return optional_element_spec_case() == kElementSpec;
836}
837inline void DataServiceMetadata::set_has_element_spec() {
838 _oneof_case_[0] = kElementSpec;
839}
840inline void DataServiceMetadata::clear_element_spec() {
841 if (has_element_spec()) {
842 optional_element_spec_.element_spec_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
843 clear_has_optional_element_spec();
844 }
845}
846inline const std::string& DataServiceMetadata::element_spec() const {
847 // @@protoc_insertion_point(field_get:tensorflow.data.DataServiceMetadata.element_spec)
848 if (has_element_spec()) {
849 return optional_element_spec_.element_spec_.GetNoArena();
850 }
851 return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
852}
853inline void DataServiceMetadata::set_element_spec(const std::string& value) {
854 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceMetadata.element_spec)
855 if (!has_element_spec()) {
856 clear_optional_element_spec();
857 set_has_element_spec();
858 optional_element_spec_.element_spec_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
859 }
860 optional_element_spec_.element_spec_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
861 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceMetadata.element_spec)
862}
863inline void DataServiceMetadata::set_element_spec(std::string&& value) {
864 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceMetadata.element_spec)
865 if (!has_element_spec()) {
866 clear_optional_element_spec();
867 set_has_element_spec();
868 optional_element_spec_.element_spec_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
869 }
870 optional_element_spec_.element_spec_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
871 // @@protoc_insertion_point(field_set_rvalue:tensorflow.data.DataServiceMetadata.element_spec)
872}
873inline void DataServiceMetadata::set_element_spec(const char* value) {
874 GOOGLE_DCHECK(value != nullptr);
875 if (!has_element_spec()) {
876 clear_optional_element_spec();
877 set_has_element_spec();
878 optional_element_spec_.element_spec_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
879 }
880 optional_element_spec_.element_spec_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
881 ::std::string(value));
882 // @@protoc_insertion_point(field_set_char:tensorflow.data.DataServiceMetadata.element_spec)
883}
884inline void DataServiceMetadata::set_element_spec(const void* value, size_t size) {
885 if (!has_element_spec()) {
886 clear_optional_element_spec();
887 set_has_element_spec();
888 optional_element_spec_.element_spec_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
889 }
890 optional_element_spec_.element_spec_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
891 reinterpret_cast<const char*>(value), size));
892 // @@protoc_insertion_point(field_set_pointer:tensorflow.data.DataServiceMetadata.element_spec)
893}
894inline std::string* DataServiceMetadata::mutable_element_spec() {
895 if (!has_element_spec()) {
896 clear_optional_element_spec();
897 set_has_element_spec();
898 optional_element_spec_.element_spec_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
899 }
900 // @@protoc_insertion_point(field_mutable:tensorflow.data.DataServiceMetadata.element_spec)
901 return optional_element_spec_.element_spec_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
902}
903inline std::string* DataServiceMetadata::release_element_spec() {
904 // @@protoc_insertion_point(field_release:tensorflow.data.DataServiceMetadata.element_spec)
905 if (has_element_spec()) {
906 clear_has_optional_element_spec();
907 return optional_element_spec_.element_spec_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
908 } else {
909 return nullptr;
910 }
911}
912inline void DataServiceMetadata::set_allocated_element_spec(std::string* element_spec) {
913 if (has_optional_element_spec()) {
914 clear_optional_element_spec();
915 }
916 if (element_spec != nullptr) {
917 set_has_element_spec();
918 optional_element_spec_.element_spec_.UnsafeSetDefault(element_spec);
919 }
920 // @@protoc_insertion_point(field_set_allocated:tensorflow.data.DataServiceMetadata.element_spec)
921}
922
923// .tensorflow.data.DataServiceMetadata.Compression compression = 2;
924inline void DataServiceMetadata::clear_compression() {
925 compression_ = 0;
926}
927inline ::tensorflow::data::DataServiceMetadata_Compression DataServiceMetadata::compression() const {
928 // @@protoc_insertion_point(field_get:tensorflow.data.DataServiceMetadata.compression)
929 return static_cast< ::tensorflow::data::DataServiceMetadata_Compression >(compression_);
930}
931inline void DataServiceMetadata::set_compression(::tensorflow::data::DataServiceMetadata_Compression value) {
932
933 compression_ = value;
934 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceMetadata.compression)
935}
936
937// int64 cardinality = 3;
938inline void DataServiceMetadata::clear_cardinality() {
939 cardinality_ = PROTOBUF_LONGLONG(0);
940}
941inline ::PROTOBUF_NAMESPACE_ID::int64 DataServiceMetadata::cardinality() const {
942 // @@protoc_insertion_point(field_get:tensorflow.data.DataServiceMetadata.cardinality)
943 return cardinality_;
944}
945inline void DataServiceMetadata::set_cardinality(::PROTOBUF_NAMESPACE_ID::int64 value) {
946
947 cardinality_ = value;
948 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceMetadata.cardinality)
949}
950
951inline bool DataServiceMetadata::has_optional_element_spec() const {
952 return optional_element_spec_case() != OPTIONAL_ELEMENT_SPEC_NOT_SET;
953}
954inline void DataServiceMetadata::clear_has_optional_element_spec() {
955 _oneof_case_[0] = OPTIONAL_ELEMENT_SPEC_NOT_SET;
956}
957inline DataServiceMetadata::OptionalElementSpecCase DataServiceMetadata::optional_element_spec_case() const {
958 return DataServiceMetadata::OptionalElementSpecCase(_oneof_case_[0]);
959}
960// -------------------------------------------------------------------
961
962// CrossTrainerCacheOptions
963
964// string trainer_id = 1;
965inline void CrossTrainerCacheOptions::clear_trainer_id() {
966 trainer_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
967}
968inline const std::string& CrossTrainerCacheOptions::trainer_id() const {
969 // @@protoc_insertion_point(field_get:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
970 return trainer_id_.GetNoArena();
971}
972inline void CrossTrainerCacheOptions::set_trainer_id(const std::string& value) {
973
974 trainer_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
975 // @@protoc_insertion_point(field_set:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
976}
977inline void CrossTrainerCacheOptions::set_trainer_id(std::string&& value) {
978
979 trainer_id_.SetNoArena(
980 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
981 // @@protoc_insertion_point(field_set_rvalue:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
982}
983inline void CrossTrainerCacheOptions::set_trainer_id(const char* value) {
984 GOOGLE_DCHECK(value != nullptr);
985
986 trainer_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
987 // @@protoc_insertion_point(field_set_char:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
988}
989inline void CrossTrainerCacheOptions::set_trainer_id(const char* value, size_t size) {
990
991 trainer_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
992 ::std::string(reinterpret_cast<const char*>(value), size));
993 // @@protoc_insertion_point(field_set_pointer:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
994}
995inline std::string* CrossTrainerCacheOptions::mutable_trainer_id() {
996
997 // @@protoc_insertion_point(field_mutable:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
998 return trainer_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
999}
1000inline std::string* CrossTrainerCacheOptions::release_trainer_id() {
1001 // @@protoc_insertion_point(field_release:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
1002
1003 return trainer_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
1004}
1005inline void CrossTrainerCacheOptions::set_allocated_trainer_id(std::string* trainer_id) {
1006 if (trainer_id != nullptr) {
1007
1008 } else {
1009
1010 }
1011 trainer_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), trainer_id);
1012 // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CrossTrainerCacheOptions.trainer_id)
1013}
1014
1015// -------------------------------------------------------------------
1016
1017// DataServiceConfig
1018
1019// .tensorflow.data.DeploymentMode deployment_mode = 1;
1020inline void DataServiceConfig::clear_deployment_mode() {
1021 deployment_mode_ = 0;
1022}
1023inline ::tensorflow::data::DeploymentMode DataServiceConfig::deployment_mode() const {
1024 // @@protoc_insertion_point(field_get:tensorflow.data.DataServiceConfig.deployment_mode)
1025 return static_cast< ::tensorflow::data::DeploymentMode >(deployment_mode_);
1026}
1027inline void DataServiceConfig::set_deployment_mode(::tensorflow::data::DeploymentMode value) {
1028
1029 deployment_mode_ = value;
1030 // @@protoc_insertion_point(field_set:tensorflow.data.DataServiceConfig.deployment_mode)
1031}
1032
1033#ifdef __GNUC__
1034 #pragma GCC diagnostic pop
1035#endif // __GNUC__
1036// -------------------------------------------------------------------
1037
1038// -------------------------------------------------------------------
1039
1040// -------------------------------------------------------------------
1041
1042
1043// @@protoc_insertion_point(namespace_scope)
1044
1045} // namespace data
1046} // namespace tensorflow
1047
1048PROTOBUF_NAMESPACE_OPEN
1049
1050template <> struct is_proto_enum< ::tensorflow::data::ProcessingModeDef_ShardingPolicy> : ::std::true_type {};
1051template <>
1052inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::ProcessingModeDef_ShardingPolicy>() {
1053 return ::tensorflow::data::ProcessingModeDef_ShardingPolicy_descriptor();
1054}
1055template <> struct is_proto_enum< ::tensorflow::data::DataServiceMetadata_Compression> : ::std::true_type {};
1056template <>
1057inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::DataServiceMetadata_Compression>() {
1058 return ::tensorflow::data::DataServiceMetadata_Compression_descriptor();
1059}
1060template <> struct is_proto_enum< ::tensorflow::data::DeploymentMode> : ::std::true_type {};
1061template <>
1062inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::data::DeploymentMode>() {
1063 return ::tensorflow::data::DeploymentMode_descriptor();
1064}
1065
1066PROTOBUF_NAMESPACE_CLOSE
1067
1068// @@protoc_insertion_point(global_scope)
1069
1070#include <google/protobuf/port_undef.inc>
1071#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdata_5fservice_2eproto
1072