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